blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 7
332
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
50
| license_type
stringclasses 2
values | repo_name
stringlengths 7
115
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 557
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.85k
684M
⌀ | star_events_count
int64 0
77.7k
| fork_events_count
int64 0
48k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 82
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 7
5.41M
| extension
stringclasses 11
values | content
stringlengths 7
5.41M
| authors
sequencelengths 1
1
| author
stringlengths 0
161
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8b98f03a62be49de597b4508264b3cc450db2dcd | 47b7aab1d865bc36b5727fb61fd6c6fa84fe6365 | /modules/jaxws-integration/test/org/apache/axis2/jaxws/provider/OMProviderTests.java | ed0327257a81da84ede3dcfbcae9fab804982280 | [
"Apache-2.0"
] | permissive | wso2/wso2-axis2 | a4150ad2acc0d5d26dae69983ca6b6ea80dc22ab | 8492fe63852762f51643d7520481198434aff236 | refs/heads/master | 2023-09-05T02:40:36.069413 | 2023-08-23T03:19:35 | 2023-08-23T03:19:35 | 16,400,174 | 40 | 215 | Apache-2.0 | 2023-08-23T02:48:14 | 2014-01-31T05:15:02 | Java | UTF-8 | Java | false | false | 5,796 | java | package org.apache.axis2.jaxws.provider;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder;
import org.apache.axis2.jaxws.Constants;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.Dispatch;
import javax.xml.ws.Service;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.Service.Mode;
import javax.xml.ws.soap.SOAPBinding;
import javax.xml.ws.soap.SOAPFaultException;
import java.io.StringReader;
import junit.framework.Test;
import junit.framework.TestSuite;
public class OMProviderTests extends ProviderTestCase {
String endpointUrl = "http://localhost:6060/axis2/services/OMProviderService.OMProviderPort";
private QName serviceName = new QName("http://ws.apache.org/axis2", "OMProviderService");
private static final String SOAP11_NS_URI = "http://schemas.xmlsoap.org/soap/envelope/";
/**
* SOAP 1.1 header
*/
private static final String SOAP11_ENVELOPE_HEAD = "<?xml version='1.0' encoding='utf-8'?>"
+ "<soapenv:Envelope xmlns:soapenv=\""
+ SOAP11_NS_URI
+ "\">"
+ "<soapenv:Header />" + "<soapenv:Body>";
/**
* SOAP 1.1 footer
*/
private static final String SOAP11_ENVELOPE_TAIL = "</soapenv:Body>"
+ "</soapenv:Envelope>";
private static String request = "<invokeOp>Hello Provider OM</invokeOp>";
private static String SOAPFaultRequest ="<invokeOp>SOAPFault</invokeOp>";
private static XMLInputFactory inputFactory = XMLInputFactory.newInstance();
public static Test suite() {
return getTestSetup(new TestSuite(OMProviderTests.class));
}
protected void setUp() throws Exception {
super.setUp();
}
/**
* Test sending a SOAP 1.2 request in MESSAGE mode
*/
public void testOMElementDispatchMessageMode() throws Exception {
// Create the JAX-WS client needed to send the request
Service service = Service.create(serviceName);
service.addPort(portName, SOAPBinding.SOAP11HTTP_BINDING, endpointUrl);
Dispatch<OMElement> dispatch = service.createDispatch(
portName, OMElement.class, Mode.MESSAGE);
// Create the OMElement object with the payload contents. Since
// we're in PAYLOAD mode, we don't have to worry about the envelope.
StringReader sr = new StringReader(SOAP11_ENVELOPE_HEAD+request+SOAP11_ENVELOPE_TAIL);
XMLStreamReader inputReader = inputFactory.createXMLStreamReader(sr);
StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inputReader, null);
SOAPEnvelope om = (SOAPEnvelope) builder.getDocumentElement();
OMElement response = dispatch.invoke(om);
String responseText = response.toStringWithConsume();
assertTrue(responseText.contains("soap"));
assertTrue(responseText.contains("Body"));
assertTrue(responseText.contains("Envelope"));
assertTrue(responseText.contains("Hello Dispatch OM"));
}
/**
* Test sending a SOAP 1.2 request in MESSAGE mode
*/
public void testOMElementDispatchMessageModeSOAPFaultException() throws Exception {
// Create the JAX-WS client needed to send the request
Service service = Service.create(serviceName);
service.addPort(portName, SOAPBinding.SOAP11HTTP_BINDING, endpointUrl);
Dispatch<OMElement> dispatch = service.createDispatch(
portName, OMElement.class, Mode.MESSAGE);
StringReader sr = new StringReader(SOAP11_ENVELOPE_HEAD+SOAPFaultRequest+SOAP11_ENVELOPE_TAIL);
XMLStreamReader inputReader = inputFactory.createXMLStreamReader(sr);
StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inputReader, null);
SOAPEnvelope om = (SOAPEnvelope) builder.getDocumentElement();
OMElement response = null;
try{
response = dispatch.invoke(om);
String responseText = response.toStringWithConsume();
}catch(Exception e){
assertTrue(e instanceof SOAPFaultException);
}
assertTrue(response ==null);
}
public void testOMElementDispatchMessageModeSOAPFault() throws Exception {
// Create the JAX-WS client needed to send the request
Service service = Service.create(serviceName);
service.addPort(portName, SOAPBinding.SOAP11HTTP_BINDING, endpointUrl);
Dispatch<OMElement> dispatch = service.createDispatch(
portName, OMElement.class, Mode.MESSAGE);
BindingProvider bp = (BindingProvider)dispatch;
bp.getRequestContext().put(Constants.THROW_EXCEPTION_IF_SOAP_FAULT, Boolean.FALSE);
StringReader sr = new StringReader(SOAP11_ENVELOPE_HEAD+SOAPFaultRequest+SOAP11_ENVELOPE_TAIL);
XMLStreamReader inputReader = inputFactory.createXMLStreamReader(sr);
StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inputReader, null);
SOAPEnvelope om = (SOAPEnvelope) builder.getDocumentElement();
OMElement response = null;
try{
response = dispatch.invoke(om);
String responseText = response.toStringWithConsume();
}catch(Exception e){
fail();
}
assertTrue(response !=null);
assertTrue(response instanceof OMElement);
}
}
| [
"[email protected]"
] | |
96396dee3d01ab4237a722dd7e49fb175413bef3 | 520d9d447ee6a0cd6a6441df6e92690bde3a672b | /src/main/java/com/net/chatroom/clink/impl/SocketChannelAdapter.java | d79ce0b6bbb27c84576e9d400d78d9c22f5c6005 | [] | no_license | HobbyBear/ChatRoom-nio | f537aa58b66e1cef5a1a2613df43f0c0622376f5 | c70cc4f3d29a3fc6dc525ecb2ab2152b4df38ab0 | refs/heads/master | 2020-06-17T13:13:51.862424 | 2019-07-09T04:58:29 | 2019-07-09T04:58:29 | 195,935,513 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,867 | java | package com.net.chatroom.clink.impl;
import com.net.chatroom.clink.core.IoArgs;
import com.net.chatroom.clink.core.IoProvider;
import com.net.chatroom.clink.core.Receiver;
import com.net.chatroom.clink.core.Sender;
import com.net.chatroom.utils.CloseUtil;
import java.io.Closeable;
import java.io.IOException;
import java.nio.channels.SocketChannel;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author: xch
* @create: 2019-07-09 10:05
**/
public class SocketChannelAdapter implements Sender, Receiver, Closeable {
private final AtomicBoolean isClosed = new AtomicBoolean(false);
private final SocketChannel channel;
private final IoProvider ioProvider;
private final OnChannelStatusChangedListener listener;
private IoArgs.IoArgsEventListener receiveIOEventListener;
public SocketChannelAdapter(SocketChannel channel, IoProvider ioProvider, OnChannelStatusChangedListener listener) throws IOException {
this.channel = channel;
this.ioProvider = ioProvider;
this.listener = listener;
channel.configureBlocking(false);
}
@Override
public boolean receiveAsync(IoArgs.IoArgsEventListener listener) throws IOException {
if (isClosed.get()) {
throw new IOException("Current channel is closed");
}
receiveIOEventListener = listener;
return ioProvider.registerInput(channel,inputCallback );
}
@Override
public boolean sendAsync(IoArgs args, IoArgs.IoArgsEventListener listener) {
return false;
}
@Override
public void close() throws IOException {
if (isClosed.compareAndSet(false, true)) {
//接触注册回调
ioProvider.unRegisterInput(channel);
ioProvider.unRegisterOutput(channel);
}
//关闭
CloseUtil.closeAll(channel);
listener.onChannelClosed(channel);
}
public interface OnChannelStatusChangedListener {
void onChannelClosed(SocketChannel channel);
}
private final IoProvider.HandleInputCallback inputCallback = new IoProvider.HandleInputCallback() {
@Override
protected void canProviderInput() {
if (isClosed.get()) {
return;
}
IoArgs args = new IoArgs();
IoArgs.IoArgsEventListener listener = SocketChannelAdapter.this.receiveIOEventListener;
if (listener != null) {
listener.onStarted(args);
}
try {
if (args.read(channel) > 0 && listener != null) {
listener.onCompleted(args);
} else {
throw new IOException("Cannot read any data");
}
} catch (IOException e) {
CloseUtil.closeAll(SocketChannelAdapter.this);
}
}
};
}
| [
"[email protected]"
] | |
0cb0f9ce7ebe6bbd0762e1af12421220b331b609 | 9c9bf69732864009870216cee7811aa6a6bcd464 | /src/main/java/com/lmt/orm/common/serivce/BaseService.java | 6b366b85c896dc177e8105338be131319c78f3cf | [] | no_license | sadness-hacker/lmt-orm-enhancer | 118a8f32268f3f3bf90b1e7ad3f6f90b7a9fdd19 | bcc503701a7ad141f76ed85a44b3747bdc9779c4 | refs/heads/master | 2021-01-16T00:46:17.415757 | 2017-08-21T09:15:24 | 2017-08-21T09:15:24 | 99,977,125 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,180 | java | package com.lmt.orm.common.serivce;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.lmt.orm.common.dao.BaseDao;
import com.lmt.orm.common.model.PaginationModel;
/**
*
* @author ducx
* @date 2017-04-11
* 对应jdbc封装的baseService
* @param <D>
* @param <T>
* @param <PK>
*/
public class BaseService<D extends BaseDao<T, PK>,T,PK> implements IBaseService<D, T, PK> {
private D baseDao;
@Autowired
public void setBaseDao(D baseDao){
this.baseDao = baseDao;
}
public D getBaseDao(){
return baseDao;
}
@Override
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public T insert(T t){
return baseDao.insert(t);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public T get(PK id) {
return baseDao.get(id);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public int update(T t) {
return baseDao.update(t);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
public int delete(PK id) {
return baseDao.delete(id);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public T load(T t) {
return baseDao.load(t);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public List<T> listAll() {
return baseDao.listAll();
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public List<T> query(T t) {
return baseDao.query(t);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public long countAll() {
return baseDao.countAll();
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public long count(String sql,Object ... params) {
return baseDao.count(sql, params);
}
@Override
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
public PaginationModel<T> list(PaginationModel<T> paginationModel) {
return baseDao.listByPagination(paginationModel);
}
}
| [
"[email protected]"
] | |
8b5dc15a96d8adea698f6ccc8dece208d04eadb2 | be73270af6be0a811bca4f1710dc6a038e4a8fd2 | /crash-reproduction-moho/results/XWIKI-14263-53-10-NSGA_II-LineCoverage:ExceptionType:StackTraceSimilarity/org/xwiki/velocity/internal/DefaultVelocityEngine_ESTest_scaffolding.java | b4d4b66d07207e0eee5bb84f81c11134477ea1d1 | [] | no_license | STAMP-project/Botsing-multi-objectivization-using-helper-objectives-application | cf118b23ecb87a8bf59643e42f7556b521d1f754 | 3bb39683f9c343b8ec94890a00b8f260d158dfe3 | refs/heads/master | 2022-07-29T14:44:00.774547 | 2020-08-10T15:14:49 | 2020-08-10T15:14:49 | 285,804,495 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 453 | java | /**
* Scaffolding file used to store all the setups needed to run
* tests automatically generated by EvoSuite
* Tue Apr 07 00:41:40 UTC 2020
*/
package org.xwiki.velocity.internal;
import org.evosuite.runtime.annotation.EvoSuiteClassExclude;
import org.junit.BeforeClass;
import org.junit.Before;
import org.junit.After;
@EvoSuiteClassExclude
public class DefaultVelocityEngine_ESTest_scaffolding {
// Empty scaffolding for empty test suite
}
| [
"[email protected]"
] | |
6152e9d90f66d8dcfaf03095274aa50ad710af73 | e07e4e5cda76e83948f22495742d78358e690a9a | /app/src/main/java/com/anddle/anddleplayer/VideoPlayer.java | f3526cfd521c9589b4b6df0c12b91d02a48babce | [] | no_license | ivy-hao/mediaPlayer_test | dfc07f7b865cd908ca5d6f9690258cae1fc57c51 | ba5f9c0a7c7788d4f4a65d0164957160303c1e08 | refs/heads/master | 2021-01-24T02:11:48.869127 | 2018-02-22T09:52:00 | 2018-02-22T09:52:00 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,366 | java | package com.anddle.anddleplayer;
import android.content.res.Configuration;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.view.MenuItem;
import android.view.WindowManager;
import android.widget.MediaController;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.VideoView;
public class VideoPlayer extends AppCompatActivity {
private VideoView mVideoView;
private int mLastPlayedTime;
private final String LAST_PLAYED_TIME = "LAST_TIME";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Uri uri = getIntent().getData();
String path = uri.getPath();
if(path == null)
{
exit();
return;
}
setContentView(R.layout.activity_video_player);
if (this.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
String[] searchKey = new String[]{
MediaStore.Video.Media.TITLE,
MediaStore.Video.Media.WIDTH,
MediaStore.Video.Media.HEIGHT,
MediaStore.Images.Media.SIZE,
MediaStore.Images.Media.DATE_ADDED
};
String where = MediaStore.Video.Media.DATA + " = '" + path + "'";
String[] keywords = null;
String sortOrder = MediaStore.Video.Media.DEFAULT_SORT_ORDER;
Cursor cursor = getContentResolver().query(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, searchKey, where, keywords, sortOrder);
if (cursor != null) {
if (cursor.getCount() > 0) {
cursor.moveToNext();
String createdTime = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_ADDED));
String name = cursor.getString(cursor.getColumnIndex(MediaStore.Video.Media.TITLE));
int size = cursor.getInt(cursor.getColumnIndex(MediaStore.Video.Media.SIZE));
int width = cursor.getInt(cursor.getColumnIndex(MediaStore.Video.Media.WIDTH));
int height = cursor.getInt(cursor.getColumnIndex(MediaStore.Video.Media.HEIGHT));
VideoItem item = new VideoItem(path, name, createdTime);
TextView title = (TextView) findViewById(R.id.video_title);
title.setText(item.name);
TextView created = (TextView) findViewById(R.id.video_create_time);
created.setText(item.createdTime);
TextView screen = (TextView) findViewById(R.id.video_width_height);
screen.setText(width + "*" + height);
TextView fileSize = (TextView) findViewById(R.id.video_size);
fileSize.setText(String.valueOf(size / 1024 / 1024) + "M");
} else {
TextView title = (TextView) findViewById(R.id.video_title);
title.setText(R.string.unknown);
TextView created = (TextView) findViewById(R.id.video_create_time);
created.setText(R.string.unknown);
TextView screen = (TextView) findViewById(R.id.video_width_height);
screen.setText(R.string.unknown);
TextView fileSize = (TextView) findViewById(R.id.video_size);
fileSize.setText(R.string.unknown);
}
cursor.close();
}
}
else {
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
getSupportActionBar().hide();
}
mVideoView = (VideoView) findViewById(R.id.video_view);
mVideoView.setVideoPath(path);
MediaController controller = new MediaController(this);
mVideoView.setMediaController(controller);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
this.finish();
default:
return super.onOptionsItemSelected(item);
}
}
@Override
protected void onPause() {
super.onPause();
mVideoView.pause();
mLastPlayedTime = mVideoView.getCurrentPosition();
}
@Override
protected void onResume() {
super.onResume();
mVideoView.start();
if(mLastPlayedTime > 0) {
mVideoView.seekTo(mLastPlayedTime);
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt(LAST_PLAYED_TIME, mVideoView.getCurrentPosition());
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
mLastPlayedTime = savedInstanceState.getInt(LAST_PLAYED_TIME);
}
private void exit()
{
Toast.makeText(this, R.string.no_playing_target, Toast.LENGTH_SHORT).show();
finish();
}
}
| [
"[email protected]"
] | |
060444bfc519d6d9b5d896fa0379b1cc02fe8a3d | a37429bcb6af25dba4497316a75840e762a850c7 | /src/main/java/org/fsoft/tms/entity/VerificationToken.java | f39c86a5eb3ad3c9e68f49d292b09b9e95082ee2 | [] | no_license | sdcrono/TMS | 198123fb189ed1c397a089dbdb8650b4c90e6b63 | 284a84b856a0444e2386e3468dbf714a87b4f12b | refs/heads/master | 2021-01-21T09:59:40.473891 | 2017-12-09T07:06:32 | 2017-12-09T07:06:32 | 91,674,841 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,181 | java | package org.fsoft.tms.entity;
import javax.persistence.*;
import java.util.Date;
import java.sql.Timestamp;
import java.util.Calendar;
/**
* Created by Isabella on 8-Jun-2017.
*/
@Entity
@Table(name = "TOKENS")
public class VerificationToken {
private static final int EXPIRATION = 60*24;
private Integer id;
private String token;
private User user;
private Date expiryDate;
private boolean isExpired;
private Date calculateExpiryDate(int expiryTimeInMinutes){
Calendar cal = Calendar.getInstance();
cal.setTime(new Timestamp(cal.getTime().getTime()));
cal.add(Calendar.MINUTE, expiryTimeInMinutes);
return new Date(cal.getTime().getTime());
}
public VerificationToken() {
}
public VerificationToken(String token, User user) {
this.token = token;
this.user = user;
}
public VerificationToken(String token, User user, Date expiryDate) {
this.token = token;
this.user = user;
this.expiryDate = expiryDate;
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "ID")
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name="TOKEN")
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
@OneToOne(targetEntity = User.class, fetch = FetchType.EAGER)
@JoinColumn(nullable = false, name = "USER_ID")
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Temporal(TemporalType.TIMESTAMP)
public Date getExpiryDate() {
return expiryDate;
}
public void setExpiryDate(Date expiryDate) {
this.expiryDate = expiryDate;
}
@Column(name="ACTIVE")
public boolean isExpired() {
return isExpired;
}
public void setExpired(boolean expired) {
isExpired = expired;
}
public void updateToken(final String token){
this.token = token;
this.expiryDate = calculateExpiryDate(EXPIRATION);
}
}
| [
"[email protected]"
] | |
c7322798ffa239ffa6102d9a054693d333f43247 | 12d9554d5499bfc35162f6e072de590c8e870880 | /src/com/izi/helpers/CalculHelper.java | 3f60ab01cf4c34fd6876ea3d21aa5a6a4f34d6fa | [] | no_license | ucefizi/calc | 7893c29310d91913abc18970877c573522bd7bf5 | 39f73169a8420337b888252ac7c9da0e2d391389 | refs/heads/master | 2022-12-21T15:07:27.306018 | 2020-09-30T09:53:20 | 2020-09-30T09:53:20 | 289,966,911 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 19,987 | java | package com.izi.helpers;
import java.util.Stack;
import com.izi.views.PlotView;
public class CalculHelper {
static char[] cara = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
static char[] num = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
static char[] tab = { '*', '/', '-', '+', '^' };
static char[] tab1 = { '*', '/', '^' };
static char[] tab2 = { '-', '+' };
static String[] fonc = { "sin", "cos", "tan", "ln", "exp", "racin", "fact", "log", "acos", "asin", "atan" };
public static String Mod_synta(String s) {
String d = "";
if (bienparenthese(s)) {
// ---------------------------------------------------------------------------------------------------------------
if (isOper("" + s.charAt(0))) {
return "ERROR SYNTAX";
}
if (isOper("" + s.charAt(s.length() - 1))) {
return "ERROR SYNTAX";
}
// -----------------------------------------------------------------------------------------------------------------
int i = 0;
while (i != s.length() - 1) {
/*-----------------------Les Modifications--------------------------------------------------------*/
if ((("" + s.charAt(i)).equals(")")) && (("" + s.charAt(i + 1)).equals("("))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta(l + k);
} // 1ere modification
// -----------------------------------------------------------------------------
if ((("" + s.charAt(i)).equals("("))
&& (("" + s.charAt(i + 1)).equals("+") || ("" + s.charAt(i + 1)).equals("-"))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "0";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta(l + k);
} // 2eme modification
// -------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
if (isNum(("" + s.charAt(i))) && (isCara("" + s.charAt(i + 1)))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta(l + k);
} // 4eme modification
// ---------------------------------------------------------------------------------
if (isNum(("" + s.charAt(i))) && (("" + s.charAt(i + 1)).equals("("))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta(l + k);
} // 5eme modification
// --------------------------------------------------------------------------
if ((("" + s.charAt(i)).equals("p")) && (("" + s.charAt(i + 1)).equals("i"))) {
String l = "", k = "";
for (int j = 0; j < i; j++) {
l = l + s.charAt(j);
}
l = l + (Math.PI);
for (int j = i + 2; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta(l + k);
}
/*--------------sytax_operation---------------------------------------------------------*/
if (isOper("" + s.charAt(i)) && isOper("" + s.charAt(i + 1))) {
return "ERROR SYNTAX";
}
if ((("" + s.charAt(i)).equals("(")) && isOperPri("" + s.charAt(i + 1))) {
return "ERROR SYNTAX";
}
if (isOper("" + s.charAt(i)) && (("" + s.charAt(i + 1)).equals(")"))) {
return "ERROR SYNTAX";
}
// ------------------------------------------------------important--------------------------
if (isCara("" + s.charAt(i))) {
d = d + s.charAt(i);
if (("" + s.charAt(i + 1)).equals("(")) {
if (!existInTab(d)) {
return "ERROR SYNTAX";
} else {
int c = 1;
String y = "";
String l = "(", k = "";
int j = i + 2;
while (c != 0) {
l = l + s.charAt(j);
if (("" + s.charAt(j)).equals("(")) {
c++;
}
if (("" + s.charAt(j)).equals(")")) {
c--;
}
j++;
}
if (!Mod_synta(l).equals("ERROR SYNTAX")) {
l = calcul_fonc(d, calcul_polopnais(polonais(Mod_synta(l))));
if (l.equals("Math Error")) {
return "Math Error";
} else {
y = l;
// System.out.println(y);
if (contient_E("" + y)) {
y = PlotView.tobigdecimal(Double.parseDouble(y));
y = y.substring(0, 12);
// System.out.println(y);
}
}
l = "";
for (int p = 0; p < i + 1 - d.length(); p++) {
l = l + s.charAt(p);
}
for (int u = j; u < s.length(); u++) {
k = k + s.charAt(u);
}
return Mod_synta(l + "(" + y + ")" + k);
}
else {
return "ERROR SYNTAX";
}
} // fin else
} // fin_if
}
i++;
} // Fin While
return s;
}
// ! (bien parenth�s�)
else {
return "ERROR SYNTAX";
}
}// fin de_la_fonction
private static boolean contient_E(String s) {
for (int i = 0; i < s.length(); i++) {
if (("" + s.charAt(i)).equals("E") && ("" + s.charAt(i + 1)).equals("-")) {
return true;
}
}
return false;
}
static double calcul_polopnais(String s) {
double l;
double k = 0;
Stack p = new Stack();
double cal = 0;
String h = "";
for (int i = 0; i < s.length(); i++) {
if ((!("" + s.charAt(i)).equals(" ")) && !isOper("" + s.charAt(i))) {
h = h + s.charAt(i);
}
if (("" + s.charAt(i)).equals(" ") && !isOper("" + s.charAt(i - 1))) {
p.push(h);
h = "";
}
if (isOper("" + s.charAt(i))) {
l = Double.parseDouble("" + p.peek());
p.pop();
k = Double.parseDouble("" + p.peek());
p.pop();
cal = calcule_1(k, l, "" + s.charAt(i));
p.push(cal);
}
}
if (h.equals("")) {
return (cal);
}
else {
return (Double.parseDouble(h));
}
}
static String polonais(String s) {
Stack<Character> p = new Stack<Character>();
String l = "";
String r = "";
for (int i = 0; i < s.length(); i++) {
if ((l + s.charAt(i)).equals("(")) {
p.push(s.charAt(i));
}
if ((l + s.charAt(i)).equals(")")) {
while (!(l + p.peek()).equals("(")) {
r = r + " " + p.peek();
p.pop();
}
p.pop();
}
// __________________________________________________________________________________________
if (isOper(l + s.charAt(i))) {
r = r + " ";
if (p.isEmpty()) {
p.push(s.charAt(i));
} else {
if (!isOper(l + p.peek())) {
p.push(s.charAt(i));
}
else {
if (priorite(l + s.charAt(i), l + p.peek())) {
p.push(s.charAt(i));
}
else {
if (!priorite(l + s.charAt(i), l + p.peek())) {
r = r + p.peek() + " ";
p.pop();
if (!p.isEmpty()) {
if (isOper(l + p.peek())) {
if (!p.isEmpty() && !priorite(l + s.charAt(i), l + p.peek())) {
r = r + p.peek() + " ";
p.pop();
p.push(s.charAt(i));
} else {
p.push(s.charAt(i));
}
}
else {
p.push(s.charAt(i));
}
} else {
p.push(s.charAt(i));
}
// -------------------------------------------------------------------------//--
}
}
}
}
// ______________________________________________________________________________________
}
if (!isOper(l + s.charAt(i)) && !(l + s.charAt(i)).equals("(") && !(l + s.charAt(i)).equals(")")) {
r = r + s.charAt(i);
}
}
while (!p.isEmpty()) {
r = r + " " + p.peek();
p.pop();
}
return (r);
}// fin_main
private static boolean isNum(String s) {
for (int i = 0; i < num.length; i++) {
if (s.equals("" + num[i])) {
return true;
}
}
return false;
}
private static boolean isCara(String c) {
for (int i = 0; i < cara.length; i++) {
if (c.equals("" + cara[i]))
return true;
}
return false;
}
// --------------------------------------------------------------------
private static String calcul_fonc(String l, double res) {
String r = "";
for (int i = 0; i < fonc.length; i++) {
if (l.equals(fonc[i])) {
try {
if (i == 10) {
r = "" + Math.atan(res);
}
if (i == 9) {
r = "" + Math.asin(res);
}
if (i == 8) {
r = "" + Math.acos(res);
}
if (i == 7) {
r = "" + Math.log10(res);
}
if (i == 6) {
int n = (int) res;
if (n != res) {
return "Math Error";
} else {
r = "" + factor(n);
}
}
if (i == 2) {
if (tan(res).equals("Math Error")) {
return "Math Error";
} else {
r = "" + tan(res);
}
}
if (i == 5) {
r = "" + Math.sqrt(res);
}
if (i == 4) {
r = "" + Math.exp(res);
}
if (i == 3) {
r = "" + Math.log(res);
}
if (i == 1) {
r = "" + cos(res);
}
if (i == 0) {
r = "" + sin(res);
}
} catch (ArithmeticException e) {
return ("Math Error");
}
}
}
return r;
}
// ---------------------------------------------------
private static double cos(double res) {
double t = Math.abs(res % Math.PI);
if (t == Math.PI / 2)
return 0;
else {
return Math.cos(res);
}
}
// ----------------------------------------------------
private static double sin(double res) {
double t = res % Math.PI / 4;
if (t == 0)
return 0;
if (t == Math.PI / 2)
return 1;
if (t == -Math.PI / 2)
return -1;
else {
return Math.sin(res);
}
}
// ----------------------------------------------------s
private static String tan(double res) {
double t = Math.abs(res % Math.PI);
if (t == 0 || t == Math.PI)
return 0 + "";
if (t == Math.PI / 2)
return "Math Error";
if (t == Math.PI / 4)
return 1 + "";
else {
return "" + Math.tan(res);
}
}
// -------------------------------------------------------------------
private static boolean existInTab(String l) {
for (int i = 0; i < fonc.length; i++) {
if (l.equals(fonc[i])) {
return true;
}
}
return false;
}
public static Boolean isOper(String c) {
String h = "";
for (int i = 0; i < tab.length; i++) {
if (c.equals(h + tab[i])) {
return true;
}
}
return false;
}
public static Boolean isOperPri(String c) {
String h = "";
for (int i = 0; i < tab1.length; i++) {
if (c.equals(h + tab1[i])) {
return true;
}
}
return false;
}
// -------------------------------------------------------------------
static boolean priorite(String op1, String op2) {
boolean b = false;
if (op1.equals("^")) {
b = true;
}
if (op1.equals("*")) {
if (op2.equals("^") || op2.equals("/"))
b = false;
else
b = true;
}
if (op1.equals("/")) {
if (op2.equals("^") || op2.equals("*"))
b = false;
else
b = true;
}
if (op1.equals("+")) {
if (op2.equals("-"))
b = false;
else
b = false;
}
if (op1.equals("-")) {
if (op2.equals("+"))
b = false;
else
b = false;
}
return b;
}
// ----------------------------------------------------------------------
public static double calcule_1(double k, double l, String s) {
double r = 0;
for (int i = 0; i < tab.length; i++) {
if (s.equals("" + tab[i])) {
if (i == 0) {
r = k * l;
}
if (i == 1) {
r = k / l;
}
if (i == 2) {
r = k - l;
}
if (i == 3) {
r = k + l;
}
if (i == 4) {
r = Math.pow(k, l);
}
}
}
return r;
}
// ----------------factoriel---------------------------------------------
public static int factor(int n) {
if (n == 0) {
return 1;
} else
return n * factor(n - 1);
}
// ---------------------------------------------------------------------
private static boolean bienparenthese(String s) {
boolean b = true;
if (s.charAt(0) == ')')
b = false;
else {
for (int i = 0; i < s.length() - 1; i++) {
if ((s.charAt(i) == '(') && (s.charAt(i + 1) == ')'))
b = false;
}
Stack<String> st = new Stack<String>();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == '(')
st.push("" + s.charAt(i));
if (s.charAt(i) == ')') {
if (st.isEmpty())
b = false;
else
st.pop();
}
}
if (!(st.isEmpty()))
b = false;
}
return b;
}
// _________________________________________________________________________________________________________________________________
public static String Cal(String s) {
try {
if (Mod_synta(s).equals("ERROR SYNTAX")) {
return ("ERROR SYNTAX");
}
if (Mod_synta(s).equals("Math Error")) {
return ("Math Error");
}
else {
return "" + calcul_polopnais(polonais(CalculHelper.Mod_synta(s)));
}
} catch (NumberFormatException e) {
return "Math Error";
}
}
// -----------------------------------------------------------------------------------------------------------------------------------
public static String Cal1(String s) {
try {
if (Mod_synta(s).equals("ERROR SYNTAX")) {
return ("ERROR SYNTAX");
}
if (Mod_synta(s).equals("Math Error")) {
return ("Math Error");
}
else {
return "" + calcul_polopnais(polonais(CalculHelper.Mod_synta1(s)));
}
} catch (NumberFormatException e) {
return "Math Error";
}
}
// ------------------------------------------------------------------------------------------------------------------------------------
public static String Mod_synta1(String s) {
String d = "";
if (bienparenthese(s)) {
// ---------------------------------------------------------------------------------------------------------------
if (isOper("" + s.charAt(0))) {
return "ERROR SYNTAX";
}
if (isOper("" + s.charAt(s.length() - 1))) {
return "ERROR SYNTAX";
}
// -----------------------------------------------------------------------------------------------------------------
int i = 0;
while (i != s.length() - 1) {
/*-----------------------Les Modifications--------------------------------------------------------*/
if ((("" + s.charAt(i)).equals(")")) && (("" + s.charAt(i + 1)).equals("("))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
} // 1ere modification
// -----------------------------------------------------------------------------
if ((("" + s.charAt(i)).equals("("))
&& (("" + s.charAt(i + 1)).equals("+") || ("" + s.charAt(i + 1)).equals("-"))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "0";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
} // 2eme modification
// -------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
if (isNum(("" + s.charAt(i))) && (isCara("" + s.charAt(i + 1)))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
} // 4eme modification
// ---------------------------------------------------------------------------------
if (isNum(("" + s.charAt(i))) && (("" + s.charAt(i + 1)).equals("("))) {
String l = "", k = "";
for (int j = 0; j <= i; j++) {
l = l + s.charAt(j);
}
l = l + "*";
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
} // 5eme modification
// --------------Problemes here
// !!!------------------------------------------------------------
if ((("" + s.charAt(i)).equals("p")) && (("" + s.charAt(i + 1)).equals("i"))) {
String l = "", k = "";
for (int j = 0; j < i; j++) {
l = l + s.charAt(j);
}
l = l + (Math.PI);
for (int j = i + 2; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
}
if (("" + s.charAt(i)).equals("E")) {
String l = "", k = "";
for (int j = 0; j < i; j++) {
l = l + s.charAt(j);
}
l = l + Math.E;
for (int j = i + 1; j < s.length(); j++) {
k = k + s.charAt(j);
}
return Mod_synta1(l + k);
}
/*--------------sytax_operation---------------------------------------------------------*/
if (isOper("" + s.charAt(i)) && isOper("" + s.charAt(i + 1))) {
return "ERROR SYNTAX";
}
if ((("" + s.charAt(i)).equals("(")) && isOperPri("" + s.charAt(i + 1))) {
return "ERROR SYNTAX";
}
if (isOper("" + s.charAt(i)) && (("" + s.charAt(i + 1)).equals(")"))) {
return "ERROR SYNTAX";
}
// ------------------------------------------------------important------------------------------------------------------------------------
if (isCara("" + s.charAt(i))) {
d = d + s.charAt(i);
if (("" + s.charAt(i + 1)).equals("(")) {
if (!existInTab(d)) {
return "ERROR SYNTAX";
} else {
int c = 1;
String l = "(", k = "";
int j = i + 2;
double m = 0;
while (c != 0) {
l = l + s.charAt(j);
if (("" + s.charAt(j)).equals("(")) {
c++;
}
if (("" + s.charAt(j)).equals(")")) {
c--;
}
j++;
}
if (!Mod_synta(l).equals("ERROR SYNTAX")) {
l = calcul_fonc1(d, calcul_polopnais(polonais(Mod_synta1(l))));
if (l.equals("Math Error")) {
return "Math Error";
} else {
m = Double.parseDouble(l);
}
l = "";
for (int p = 0; p < i + 1 - d.length(); p++) {
l = l + s.charAt(p);
}
for (int u = j; u < s.length(); u++) {
k = k + s.charAt(u);
}
return Mod_synta1(l + "(" + m + ")" + k);
}
else {
return "ERROR SYNTAX";
}
} // fin else
} // fin_if
}
i++;
} // Fin While
return s;
}
// ! (bien parenth�s�)
else {
return "ERROR SYNTAX";
}
}// fin de_la_fonction
// --------------------------------------------------------
private static String calcul_fonc1(String l, double res) {
String r = "";
for (int i = 0; i < fonc.length; i++) {
if (l.equals(fonc[i])) {
try {
if (i == 10) {
r = "" + Math.atan(res);
}
if (i == 9) {
r = "" + Math.asin(res);
}
if (i == 8) {
r = "" + Math.acos(res);
}
if (i == 7) {
r = "" + Math.log10(res);
}
if (i == 6) {
int n = (int) res;
if (n != res) {
return "Math Error";
} else {
r = "" + factor(n);
}
}
if (i == 2) {
if (tan(Math.toRadians(res)).equals("Math Error")) {
return "Math Error";
} else {
r = "" + tan(Math.toRadians(res));
}
}
if (i == 1) {
r = "" + cos(Math.toRadians(res));
}
if (i == 0) {
r = "" + sin(Math.toRadians(res));
}
if (i == 5) {
r = "" + Math.sqrt(res);
}
if (i == 4) {
r = "" + Math.exp(res);
}
if (i == 3) {
r = "" + Math.log(res);
}
} catch (ArithmeticException e) {
return ("Math Error");
}
}
}
return r;
}
}
| [
"[email protected]"
] | |
c51309c92665bf28dbbeeb3a30b39602d93c8a9a | f6e6e42dfd96f77df0f9a714941ea475843a3b85 | /src/main/java/com/springtutor/controllers/RegistrationController.java | 7332ba1660a684fa8913add6278ec033b9aa594a | [] | no_license | almirpehratovic/springtutor001 | 859c169d181eadaf7a841eb886abb58fc181677b | d6a6d1fd13c2d6abf1f9cf06eb126907e4429fa1 | refs/heads/master | 2016-09-08T01:28:58.180502 | 2015-08-24T12:07:51 | 2015-08-24T12:07:51 | 41,291,184 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,730 | java | package com.springtutor.controllers;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import com.springtutor.model.Status;
@Controller
@RequestMapping("/register")
public class RegistrationController {
private static final String[] reservedUsernames = { "spring", "tutor",
"java" };
@RequestMapping(method = RequestMethod.POST)
public String register(@RequestParam("username") String username,
@RequestParam("password") String password, Model model) {
String message = "User " + username + " successfully registered.";
for (String reserved : reservedUsernames) {
if (reserved.equals(username)) {
message = "Sorry, username " + username + " is reserved";
break;
}
}
model.addAttribute("message", message);
System.out.println("registration success");
return "showMessage";
}
@RequestMapping(value = "/check", method = RequestMethod.GET)
@ResponseBody
public Status checkIsAvailable(String username) {
boolean isOk = true;
if (username.length() < 5) {
isOk = false;
} else {
for (String reserved : reservedUsernames) {
if (reserved.equals(username)) {
isOk = false;
break;
}
}
}
Status status = new Status();
status.setOk(isOk);
if (isOk) {
status.setMessage("Username is available");
} else {
status.setMessage("Sorry, username is not available or not accepted");
}
return status;
}
}
| [
"[email protected]"
] | |
449ddebab6e8f6356c51398f8dad6c2606409090 | 61900370be56fc1f22cddf9e93bde0dd8edeb770 | /timealbum-master/SharePhoto/album/src/main/java/com/ibbhub/album/AlbumFragment.java | 99f84231efeb49a2706fe5d324ef1eb9a2f7d9a2 | [] | no_license | Z-KL/SharePhoto8-16 | 23191c0a3853abfaab4d7036edd4b997422206ab | 8b82806f0e90f68d8fba078b727c2c7eb8844dc7 | refs/heads/master | 2020-07-05T13:07:53.269745 | 2019-08-16T03:58:35 | 2019-08-16T03:58:35 | 202,655,424 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 13,348 | java | package com.ibbhub.album;
import android.content.DialogInterface;
import android.net.Uri;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ProgressBar;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import io.reactivex.Observable;
import io.reactivex.functions.BiConsumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Predicate;
import io.reactivex.schedulers.Schedulers;
/**
* @author ：chezi008 on 2018/8/1 22:34
* @description ：时间相册显示的主页面
* @email ：[email protected]
*/
public abstract class AlbumFragment extends Fragment implements TimeAlbumListener {
public static boolean isChooseMode = false;
private String TAG = getClass().getSimpleName();
private List<TimeBean> mData = new ArrayList<>();
private TimeAdapter mAdapter;
private RecyclerView rc_list;
private ProgressBar pb_loading;
private AlbumBottomMenu album_menu;
private List<TimeBean> choosedCache = new ArrayList<>();
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EventBus.getDefault().register(this);
}
@Override
public void onDestroy() {
super.onDestroy();
EventBus.getDefault().unregister(this);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_album, container, false);
return view;
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
initView(view);
initVariable();
initData();
}
private void initVariable() {
isChooseMode = false;
TaShareManager.getInstance().setFileProviderName(fileProviderName());
TaHelper.getInstance().setAdapterListener(new AdapterListener<AlbumBean>() {
@Override
public void onItemClick(AlbumBean albumBean, View v) {
TimeBean timeBean = new TimeBean();
timeBean.setDate(albumBean.date);
if (isChooseMode) {
int index = choosedCache.indexOf(timeBean);
List<AlbumBean> mbList;
if (index < 0) {
//被选中
mbList = new ArrayList<>();
mbList.add(albumBean);
timeBean.setItemList(mbList);
choosedCache.add(timeBean);
} else {
mbList = choosedCache.get(index).itemList;
//如果被选中，则添加到缓存中
if (albumBean.isChecked) {
mbList.add(albumBean);
} else {
mbList.remove(albumBean);
if (mbList.size() == 0) {
choosedCache.remove(index);
}
}
// Log.d(TAG, "onItemClick: choosedCacheSize:"+mbList.size());
}
} else {
int index = mData.indexOf(timeBean);
TimeBean ab = mData.get(index);
index = ab.itemList.indexOf(albumBean);
if (index >= 0) {
start2Preview((ArrayList<AlbumBean>) ab.itemList, index);
}
}
}
@Override
public void onItemLongClick(AlbumBean albumBean, View v) {
//进入选择模式
enterChoose();
}
});
TaHelper.getInstance()
.setSrcFiles(buildAlbumSrc())
.setTbDecoration(buildDecoration())
.setLoadImageListener(this);
}
private void initView(View view) {
pb_loading = view.findViewById(R.id.pb_loading);
album_menu = view.findViewById(R.id.album_menu);
rc_list = view.findViewById(R.id.rc_list);
mAdapter = new TimeAdapter(mData);
rc_list.setLayoutManager(new LinearLayoutManager(getContext()));
rc_list.setAdapter(mAdapter);
album_menu.setMenuListener(new AlbumBottomMenu.AlubmBottomMenuListener() {
@Override
public void onDeleteClick() {
showConfirmDelete();
}
@Override
public void onShareClick() {
//分享
processShare();
}
});
}
/**
* 弹出确认删除提示
*/
private void showConfirmDelete() {
AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
builder.setTitle("删除照片");
builder.setMessage("确认是否删除照片？");
builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
processDelete();
}
});
builder.setNegativeButton("取消", null);
builder.show();
}
private Calendar cal1 = Calendar.getInstance();
private void initData() {
List<File> fileList = TaHelper.getInstance().getSrcFiles();
Observable.fromIterable(fileList)
.flatMapIterable(new Function<File, Iterable<File>>() {
@Override
public Iterable<File> apply(File file) throws Exception {
return Arrays.asList(file.listFiles());
}
})
.filter(new Predicate<File>() {
@Override
public boolean test(File it) throws Exception {
// Log.d(TAG, "test: "+it.getAbsolutePath());
return obtainFile(it);
}
})
.map(new Function<File, AlbumBean>() {
@Override
public AlbumBean apply(File file) throws Exception {
Date fileDate = FileUtils.parseDate(file);
cal1.setTime(fileDate);
// 将时分秒,毫秒域清零
cal1.set(Calendar.HOUR_OF_DAY, 0);
cal1.set(Calendar.MINUTE, 0);
cal1.set(Calendar.SECOND, 0);
cal1.set(Calendar.MILLISECOND, 0);
AlbumBean albumBean = new AlbumBean();
albumBean.date = cal1.getTime().getTime();
albumBean.path = file.getAbsolutePath();
return albumBean;
}
})
.collect(new Callable<List<TimeBean>>() {
@Override
public List<TimeBean> call() throws Exception {
return new ArrayList<>();
}
}, new BiConsumer<List<TimeBean>, AlbumBean>() {
@Override
public void accept(List<TimeBean> timeBeans, AlbumBean albumBean) throws Exception {
TimeBean timeBean = new TimeBean();
timeBean.setDate(albumBean.date);
int index = timeBeans.indexOf(timeBean);
if (index >= 0) {
timeBeans.get(index).itemList.add(albumBean);
} else {
timeBean.itemList.add(albumBean);
timeBeans.add(timeBean);
}
}
})
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.io())
.subscribe(new BiConsumer<List<TimeBean>, Throwable>() {
@Override
public void accept(List<TimeBean> timeBeans, Throwable throwable) throws Exception {
if (timeBeans != null) {
mData.addAll(timeBeans);
sortList();
}
}
});
}
/**
* 数据根据时间进行排序
*/
private void sortList() {
Collections.sort(mData, new Comparator<TimeBean>() {
@Override
public int compare(TimeBean o1, TimeBean o2) {
if (o1.date > o2.date) {
return -1;
} else if (o1.date == o2.date) {
return 0;
}
return 1;
}
});
getActivity().runOnUiThread(new Runnable() {
@Override
public void run() {
pb_loading.setVisibility(View.GONE);
rc_list.setVisibility(View.VISIBLE);
mAdapter.notifyDataSetChanged();
}
});
}
/**
* 处理分享
*/
private void processShare() {
//判断是多张还是单张
if (choosedCache.size() == 1 && choosedCache.get(0).itemList.size() == 1) {
//单张
AlbumBean albumBean = choosedCache.get(0).itemList.get(0);
TaShareManager.getInstance().openShare(getContext(), albumBean.path);
} else {
//多张
ArrayList<Uri> uriList = new ArrayList<>();
for (int i = 0; i < choosedCache.size(); i++) {
for (AlbumBean mb :
choosedCache.get(i).itemList) {
uriList.add(Uri.fromFile(new File(mb.path)));
}
}
TaShareManager.getInstance().openShare(getContext(), uriList);
}
cancelChoose();
}
/**
* 处理照片删除
*/
private void processDelete() {
//判断是多张还是单张
if (choosedCache.size() == 1 && choosedCache.get(0).itemList.size() == 1) {
//单张
AlbumBean albumBean = choosedCache.get(0).itemList.get(0);
notifyAlbumRemove(albumBean);
} else {
//多张
for (int i = 0; i < choosedCache.size(); i++) {
// Log.d(TAG, "processDelete: choosedCache.get(i).itemList："+ choosedCache.get(i).itemList.size());
for (AlbumBean mb :
choosedCache.get(i).itemList) {
notifyAlbumRemove(mb);
}
}
}
choosedCache.clear();
}
private void notifyAlbumRemove(AlbumBean albumBean) {
FileUtils.delete(albumBean.path);
int index = mData.indexOf(new TimeBean(albumBean.date));
// Log.d(TAG, "notifyAlbumRemove: index:"+index);
TimeBean tb = mData.get(index);
tb.itemList.remove(albumBean);
if (tb.itemList.size() == 0) {
mData.remove(index);
}
mAdapter.notifyItemChanged(index);
}
/**
* 取消选择
*/
public void cancelChoose() {
for (int i = 0; i < choosedCache.size(); i++) {
for (AlbumBean mb :
choosedCache.get(i).itemList) {
mb.isChecked = false;
}
}
choosedCache.clear();
isChooseMode = false;
TaHelper.getInstance().onChooseModeChange(isChooseMode);
mAdapter.notifyDataSetChanged();
album_menu.setVisibility(View.GONE);
}
/**
* 进入选择
*/
public void enterChoose() {
isChooseMode = true;
TaHelper.getInstance().onChooseModeChange(true);
mAdapter.notifyDataSetChanged();
album_menu.setVisibility(View.VISIBLE);
}
/**
* 设置相册的媒体源
*
* @return
*/
public abstract List<File> buildAlbumSrc();
public abstract Boolean obtainFile(File file);
/**
* 设置recyclerView的装饰器
*
* @return
*/
public abstract ITaDecoration buildDecoration();
public abstract String fileProviderName();
/**
* 跳转至预览界面
*
* @param data 预览数据
* @param pos 当前选择albumBean 的位置
*/
protected void start2Preview(ArrayList<AlbumBean> data, int pos) {
AlbumPreviewActivity.start(getContext(), data, pos);
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void processDeleteEvent(DeleteEvent event){
notifyAlbumRemove(event.albumBean);
}
}
| [
"[email protected]"
] | |
8c46dc8b5c9bb473c700a7c75595057bb16475dc | 394395ffaf20bf4103a666e48b473ecb0aa19e72 | /src/main/java/com/toko/maju/repository/ProjectProductRepository.java | 95ce22be81adce124cf2de8203b4a75e9647a9bc | [
"Apache-2.0"
] | permissive | BulkSecurityGeneratorProject/jhip-toko-maju | 5abe09bf7f68f3ee6e290c1828dbf19c34467eb5 | ff6c054ee709f79a2a7f5c92d4b5a1ccccdb3191 | refs/heads/master | 2022-12-16T00:00:57.085407 | 2019-05-11T07:38:45 | 2019-05-11T07:38:45 | 296,606,996 | 0 | 0 | Apache-2.0 | 2020-09-18T11:53:24 | 2020-09-18T11:53:23 | null | UTF-8 | Java | false | false | 420 | java | package com.toko.maju.repository;
import com.toko.maju.domain.ProjectProduct;
import org.springframework.data.jpa.repository.*;
import org.springframework.stereotype.Repository;
/**
* Spring Data repository for the ProjectProduct entity.
*/
@SuppressWarnings("unused")
@Repository
public interface ProjectProductRepository extends JpaRepository<ProjectProduct, Long>, JpaSpecificationExecutor<ProjectProduct> {
}
| [
"[email protected]"
] | |
86a9e923fe17335f63b7f19bb836bda1fdb4380e | 10fc131260c1ac2505f3bd9acd7b41df1fd6adc2 | /Classifiers/Test 3 (9 attributes)/Player.java | 86564bf4530df544f8bb969205338d2553804c22 | [] | no_license | pp1856/Agent-Training | 546b16a24c894bb64f0137fd3e50474aec72846f | 8332124810b3224550efaff0223c7f4c73863c34 | refs/heads/master | 2023-01-01T18:52:06.849521 | 2020-10-24T09:45:40 | 2020-10-24T09:45:40 | 306,833,022 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,226 | java | class Player {
public static double classify(Object[] i)
throws Exception {
double p = Double.NaN;
p = Player.Nad490ebf0(i);
return p;
}
static double Nad490ebf0(Object []i) {
double p = Double.NaN;
if (i[2] == null) {
p = 0;
} else if (i[2].equals("sabio")) {
p = Player.Nb14ffc491(i);
} else if (i[2].equals("valiente")) {
p = 1;
} else if (i[2].equals("prudente")) {
p = Player.N736db4422(i);
} else if (i[2].equals("pasivo")) {
p = 1;
}
return p;
}
static double Nb14ffc491(Object []i) {
double p = Double.NaN;
if (i[6] == null) {
p = 0;
} else if (i[6].equals("bueno")) {
p = 0;
} else if (i[6].equals("asustado")) {
p = 0;
} else if (i[6].equals("kamikaze")) {
p = 1;
} else if (i[6].equals("malo")) {
p = 0;
}
return p;
}
static double N736db4422(Object []i) {
double p = Double.NaN;
if (i[6] == null) {
p = 1;
} else if (i[6].equals("bueno")) {
p = 1;
} else if (i[6].equals("asustado")) {
p = 0;
} else if (i[6].equals("kamikaze")) {
p = 1;
} else if (i[6].equals("malo")) {
p = 1;
}
return p;
}
}
| [
"[email protected]"
] | |
6c2046bb6cd1a05ba27c1dbd4b5533310ae8d2e4 | 8c907d0221ddf81dd61eaad2604afa607b708c7a | /src/oop/interface_demo/HddRepository.java | 601f8f6d85b6bfcb21e18633166cd321b7b61f44 | [] | no_license | dixu11/SDA-zaawansowane | ccbb47491c02dac006fefaa8fbb02cc253126a07 | 689afb810330629ed3b45869666c4d6b766e07aa | refs/heads/master | 2022-12-01T14:14:47.214119 | 2020-08-08T11:48:54 | 2020-08-08T11:48:54 | 275,354,494 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 274 | java | package oop.interface_demo;
public class HddRepository implements Repository {
public void loadData() {
System.out.println("Wczytuję dane z dysku");
}
public void saveData() {
System.out.println("Zapisuję dane aplikacji na dysku");
}
}
| [
"[email protected]"
] | |
77feebcb7eb01935c6218ce901a6491ae420298c | e2c36ccb265665c77b716a1d736f55f59cf30acf | /src/com/petrusandrey/Circle.java | 4da3747c34ca9032c407560d0859cda90407064d | [] | no_license | APAndrey/HomeWork11 | fe37d03db5b591b5b1b272139165a0a9c60f7de8 | e23704eb8ac83470b5bbcf992d8070315d2cbbbb | refs/heads/master | 2020-04-29T00:32:45.153441 | 2019-03-14T20:50:06 | 2019-03-14T20:50:06 | 175,697,429 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,641 | java | package com.petrusandrey;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import java.util.Random;
public class Circle implements Shape{
private static double diameter = 30;
private Board board;
private GraphicsContext gc;
private double x;
private double y;
private double xSpeed;
private double ySpeed;
public Circle(Board board, GraphicsContext gc, double x, double y) {
this.board = board;
this.gc = gc;
this.x = x;
this.y = y;
Random random = new Random();
xSpeed = 2 + random.nextInt(4);
ySpeed = 2 + random.nextInt(1);
}
@Override
public void move() {
x += xSpeed;
y += ySpeed;
if (handleСollision()) {
return;
}
if (x + diameter > gc.getCanvas().getWidth()) {
setDirectionLeft();
}
if (y + diameter > gc.getCanvas().getHeight()) {
setDirectionTop();
}
if (x < 0) {
setDirectionRight();
}
if (y < 0) {
setDirectionBottom();
}
}
/**
* @return is collision
*/
private boolean handleСollision() {
for (Shape shape : board.getShapes()) {
if (shape == this) {
continue;
}
if (shape.getDistance(x, y) < diameter) {
if (x < shape.getX()) {
setDirectionLeft();
} else {
setDirectionRight();
}
if (y < shape.getY()) {
setDirectionTop();
} else {
setDirectionBottom();
}
return true;
}
}
return false;
}
@Override
public void draw() {
gc.setFill(Color.RED);
gc.setStroke(Color.BLACK);
gc.setLineWidth(2);
gc.fillOval(x, y, diameter, diameter);
gc.strokeOval(x, y, diameter, diameter);
}
@Override
public double getDistance(double x, double y) {
return Math.sqrt(Math.pow(this.x - x, 2) + Math.pow(this.y - y, 2));
}
@Override
public double getX() {
return x;
}
@Override
public double getY() {
return y;
}
private void setDirectionLeft() {
xSpeed = -Math.abs(xSpeed);
}
private void setDirectionRight() {
xSpeed = Math.abs(xSpeed);
}
private void setDirectionTop() {
ySpeed = -Math.abs(ySpeed);
}
private void setDirectionBottom() {
ySpeed = Math.abs(ySpeed);
}
}
| [
"[email protected]"
] | |
33ba5dc6d573ca45aa5b08b12eea7b54c8cbd80b | a7b50156b58c8d0f7c0a297f3acdee9980bfa448 | /src/com/hospital/service/IDoctorService.java | ef580bfed3d5925530ca23d9a684928c6b1f60a7 | [] | no_license | wenhuikaa/National-health-clinic | 227f246da34712cfec3153526a3e4b02973c4d16 | 5e17932a8087eafba792d978c169778e88ce535c | refs/heads/master | 2020-06-01T16:51:19.376266 | 2019-06-12T01:45:23 | 2019-06-12T01:45:23 | 190,855,821 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 927 | java | /**
*
*/
package com.hospital.service;
import java.util.List;
import com.hospital.model.DoctorDomain;
import com.hospital.model.DoctorTitleDomain;
import com.hospital.model.HospitalDomain;
import com.hospital.model.PageDomain;
public interface IDoctorService {
List<DoctorDomain> queryDoctorList(String docName, String docTitle,String hosName,PageDomain pageDomain);
//判断添加医师是否成功
Boolean addDoctor(DoctorDomain doctorDomain);
//获取所有的医师职称
List<DoctorTitleDomain> queryDoctorTitleList();
//删除医师
Integer deleteDoctor(Integer docId);
//编辑医师，根据docId查询单条数据
DoctorDomain getDoctor(Integer docId);
//修改医师信息
Integer updateDoctor(DoctorDomain doctorDomain);
//无条件查询医师列表
List<DoctorDomain> getAllDoctors();
Integer updateHosSelected(String hosName);
HospitalDomain getHosSelected();
}
| [
"[email protected]"
] | |
911a76da39ddb95c3f6045c56d9d7710ef825917 | aa5f25d714519ccfda2a89f382dfcefe1b3642fc | /trunk/dmisArea/src/com/techstar/dmis/service/impl/ZdhSrapplicationServiceImpl.java | 8b17e2ca0768b311ec914b9296430d1e944fb353 | [] | no_license | BGCX261/zhouwei-repository-svn-to-git | 2b85060757568fadc0d45b526e2546ed1965d48a | cd7f50db245727418d5f1c0061681c11703d073e | refs/heads/master | 2021-01-23T03:44:27.914196 | 2015-08-25T15:45:29 | 2015-08-25T15:45:29 | 41,599,666 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 42,620 | java | package com.techstar.dmis.service.impl;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.StopWatch;
import com.techstar.framework.dao.IBaseJdbcDao;
import com.techstar.framework.dao.model.QueryListObj;
import com.techstar.framework.utils.BeanHelper;
import com.techstar.framework.utils.SequenceCreator;
import com.techstar.dmis.common.ZdhConstants;
import com.techstar.dmis.dao.*;
import com.techstar.dmis.dto.ZdhAutoondutylogDto;
import com.techstar.dmis.dto.ZdhSrapplicationDto;
import com.techstar.dmis.dto.ZdhTransrecordDto;
import com.techstar.dmis.entity.CtrlWflentityrel;
import com.techstar.dmis.entity.ZdhSrapplication;
import com.techstar.dmis.service.IZdhSrapplicationService;
import com.techstar.dmis.service.IZdhTransrecordService;
import com.techstar.dmis.service.workflow.IZdhSrapplicationWFService;
import com.techstar.dmis.service.workflow.IZdhWorkbillWFService;
import org.springframework.dao.DataAccessException;
//消息处理
import com.techstar.exchange.convert.*;
import com.techstar.exchange.dto.control.AttachmentDto;
import com.techstar.exchange.dto.control.ControlDto;
import com.techstar.exchange.dto.control.RecvDto;
import com.techstar.exchange.service.IexchangeService;
import com.techstar.exchange.service.impl.ExchangeServiceImpl;
import com.techstar.exchange.transfers.utils.*;
import com.techstar.dmis.util.*;
//注册子表DAO
import com.techstar.dmis.dto.ZdhSrappeqprelDto;
import com.techstar.dmis.entity.ZdhSrappeqprel;
import com.techstar.dmis.helper.dto.WorkflowHandleDto;
//please add your business methods start
// to do it
//add your business method end
/**
* 业务对象服务接口实现类
* @author
* @date
*/
public class ZdhSrapplicationServiceImpl implements IZdhSrapplicationService {
//注册DAO
private IZdhSrapplicationDao zdhSrapplicationDao;
private IBaseJdbcDao baseJdbcDao;
//注册管理DAO
private IZdhSrappeqprelDao zdhSrappeqprelDao;
public void setZdhSrappeqprelDao
(IZdhSrappeqprelDao zdhSrappeqprelDao) {
this.zdhSrappeqprelDao = zdhSrappeqprelDao;
}
//注册工作流
private IZdhSrapplicationWFService zdhSrapplicationWFServiceImpl;
public IZdhSrapplicationWFService getZdhSrapplicationWFServiceImpl() {
return zdhSrapplicationWFServiceImpl;
}
public void setZdhSrapplicationWFServiceImpl(IZdhSrapplicationWFService zdhSrapplicationWFServiceImpl) {
this.zdhSrapplicationWFServiceImpl = zdhSrapplicationWFServiceImpl;
}
//注册传动记录service
IZdhTransrecordService zdhTransrecordService;
public IZdhTransrecordService getZdhTransrecordService() {
return zdhTransrecordService;
}
public void setZdhTransrecordService(
IZdhTransrecordService zdhTransrecordService) {
this.zdhTransrecordService = zdhTransrecordService;
}
//注册停复役与传动记录的对应关系
ICtrlWflentityrelDao ctrlWflentityrelDao;
public ICtrlWflentityrelDao getCtrlWflentityrelDao() {
return ctrlWflentityrelDao;
}
public void setCtrlWflentityrelDao(ICtrlWflentityrelDao ctrlWflentityrelDao) {
this.ctrlWflentityrelDao = ctrlWflentityrelDao;
}
public ZdhSrapplicationServiceImpl() {}
/**
* 保存新增的数据
*/
public void addZdhSrapplication(ZdhSrapplicationDto dto) {
if (StringUtils.isEmpty(dto.getFapplicationno())){
if( StringUtils.isEmpty(dto.getFapplicationno())){
dto.setFapplicationno(new SequenceCreator().getUID());
}
}
//将数据所属单位修改为DMIS_ZD_STD_DISPATCHUNIT表中的ESHIRTNAME英文简称
String dataOwnerName = dto.getSys_dataowner();
String eshirtname = this.getDataOwner(dataOwnerName);
dto.setSys_dataowner(eshirtname);
//新增时候,主对象不用管子对象的保存
ZdhSrapplication zdhSrapplication = (ZdhSrapplication) BeanHelper.buildBean(ZdhSrapplication.class, dto);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
//用于实现基本增加或修改操作
public void saveOrUpdateZdhSrapplication(ZdhSrapplicationDto dto) {
if (StringUtils.isEmpty(dto.getFapplicationno())){
if( StringUtils.isEmpty(dto.getFapplicationno())){
dto.setFapplicationno(new SequenceCreator().getUID());
}
}
//将数据所属单位修改为DMIS_ZD_STD_DISPATCHUNIT表中的ESHIRTNAME英文简称
String dataOwnerName = dto.getSys_dataowner();
String eshirtname = this.getDataOwner(dataOwnerName);
dto.setSys_dataowner(eshirtname);
ZdhSrapplication zdhSrapplication = (ZdhSrapplication) BeanHelper.buildBean(ZdhSrapplication.class, dto);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
//生成传动记录(要在)
//this.genTransrecord(dto);
}
//用于实现基本删除操作
public void deleteZdhSrapplication(String zdhSrapplicationId) {
ZdhSrapplication zdhSrapplication = new ZdhSrapplication();
zdhSrapplication.setFapplicationno(zdhSrapplicationId);
zdhSrapplicationDao.delete(zdhSrapplication);
}
//用于实现基本删除集合操作
public void deleteZdhSrapplication(List dtos){
List pos = new ArrayList();
pos = (List)BeanHelper.mapBeans(ZdhSrapplication.class, dtos);
zdhSrapplicationDao.deleteAll(pos);
}
//用于实现基本DTOLOAD操作
public ZdhSrapplicationDto loadZdhSrapplication(String fapplicationno) {
ZdhSrapplication zdhSrapplication = (ZdhSrapplication) zdhSrapplicationDao.findByPk(fapplicationno);
ZdhSrapplicationDto dto = (ZdhSrapplicationDto) BeanHelper.buildBean(ZdhSrapplicationDto.class, zdhSrapplication);
return dto;
}
//用于实现列表操作
public QueryListObj listZdhSrapplication() {
QueryListObj obj = zdhSrapplicationDao.getQueryList();
if (obj.getElemList() != null) {
List dtos = (List) BeanHelper.buildBeans(ZdhSrapplicationDto.class, obj
.getElemList());
obj.setElemList(dtos);
}
return obj;
}
public QueryListObj listZdhSrapplicationByHql(String hql) {
QueryListObj obj = zdhSrapplicationDao.getQueryListByHql(hql);
if (obj.getElemList() != null) {
List dtos = (List) BeanHelper.buildBeans(ZdhSrapplicationDto.class, obj
.getElemList());
obj.setElemList(dtos);
}
return obj;
}
public QueryListObj getZdhSrapplicationByHql(String hql, int beginPage, int pageSize, String sql) {
QueryListObj obj = zdhSrapplicationDao.getQueryListByHql(hql, beginPage, pageSize);
if (obj.getElemList() != null) {
List dtos = (List) BeanHelper.buildBeans(ZdhSrapplicationDto.class, obj
.getElemList());
obj.setElemList(dtos);
}
List sumList = zdhSrapplicationDao.getObjPropertySums(sql);
//System.out.println("sumList.size():"+sumList.size());
obj.setPropertySum(sumList);
return obj;
}
/**
* @business method list
* @申请单执行完成
* @审批意见下发
* @报上级调度
* @停复役申请归档
* @从设备台帐选择多台设备
*/
//please add your business methods start
// to do it
//add your business method end
public IZdhSrapplicationDao getZdhSrapplicationDao() {
return zdhSrapplicationDao;
}
public void setZdhSrapplicationDao(IZdhSrapplicationDao zdhSrapplicationDao) {
this.zdhSrapplicationDao = zdhSrapplicationDao;
}
public void setBaseJdbcDao(IBaseJdbcDao baseJdbcDao) {
this.baseJdbcDao = baseJdbcDao;
}
public void saveOrUpdateZdhSrapplication(List dtos) {
List pos = new ArrayList();
for(int i=0;i<dtos.size();i++){
ZdhSrapplicationDto zdhSrapplicationDto = (ZdhSrapplicationDto)dtos.get(i);
ZdhSrapplication zdhSrapplication = (ZdhSrapplication) BeanHelper.buildBean(ZdhSrapplication.class, zdhSrapplicationDto);
pos.add(zdhSrapplication);
}
zdhSrapplicationDao.saveOrUpdateAll(pos);
//生成传动记录
/*for(int i=0;i<dtos.size();i++){
ZdhSrapplicationDto zdhSrapplicationDto = (ZdhSrapplicationDto)dtos.get(i);
this.genTransrecord(zdhSrapplicationDto);
}
*/
}
//子表处理DAO
public QueryListObj listZdhSrappeqprel() {
QueryListObj obj = zdhSrappeqprelDao.getQueryList();
if (obj.getElemList() != null) {
List dtos = (List) BeanHelper.buildBeans(ZdhSrappeqprelDto.class, obj
.getElemList());
obj.setElemList(dtos);
}
return obj;
}
public void saveOrUpdateZdhSrappeqprel(ZdhSrappeqprelDto dto){
if (StringUtils.isEmpty(dto.getFid())){
if( StringUtils.isEmpty(dto.getFid())){
dto.setFid(new SequenceCreator().getUID());
}
}
ZdhSrappeqprel zdhSrappeqprel = (ZdhSrappeqprel) BeanHelper.buildBean(ZdhSrappeqprel.class, dto);
zdhSrappeqprelDao.saveOrUpdate(zdhSrappeqprel);
}
public void deleteZdhSrappeqprel(String fid){
ZdhSrappeqprel zdhSrappeqprel = new ZdhSrappeqprel();
zdhSrappeqprel.setFid(fid);
zdhSrappeqprelDao.delete(zdhSrappeqprel);
}
public ZdhSrappeqprelDto loadZdhSrappeqprel(String fid){
ZdhSrappeqprel zdhSrappeqprel = (ZdhSrappeqprel) zdhSrappeqprelDao.findByPk(fid);
ZdhSrappeqprelDto dto = (ZdhSrappeqprelDto) BeanHelper.buildBean(ZdhSrappeqprelDto.class, zdhSrappeqprel);
return dto;
}
public QueryListObj listZdhSrappeqprelByHql(String hql){
QueryListObj obj = zdhSrappeqprelDao.getQueryListByHql(hql);
if (obj.getElemList() != null) {
List dtos = (List) BeanHelper.buildBeans(ZdhSrappeqprelDto.class, obj
.getElemList());
obj.setElemList(dtos);
}
return obj;
}
public void saveOrUpdateZdhSrappeqprel(List dtos){
List pos = new ArrayList();
for(int i=0;i<dtos.size();i++){
ZdhSrappeqprelDto zdhSrappeqprelDto = (ZdhSrappeqprelDto)dtos.get(i);
ZdhSrappeqprel zdhSrappeqprel = (ZdhSrappeqprel) BeanHelper.buildBean(ZdhSrappeqprel.class, zdhSrappeqprelDto);
pos.add(zdhSrappeqprel);
}
zdhSrappeqprelDao.saveOrUpdateAll(pos);
}
public void deleteZdhSrappeqprel(List dtos){
List pos = new ArrayList();
pos = (List)BeanHelper.buildBean(ZdhSrappeqprel.class, dtos);
zdhSrappeqprelDao.deleteAll(pos);
}
/**
* 根据数据所属单位名称获取数据所属单位的缩写
* 即在表DMIS_ZD_STD_DISPATCHUNIT中,根据UNITNAME的值获取ESHIRTNAME的值
* @param dataownerName
* @return
*/
public String getDataOwner(String dataownerName){
System.out.println("dataownerName:"+dataownerName);
if (dataownerName == null || dataownerName.equalsIgnoreCase("") ) {
return "CQ";
}
String hql = "select a.eshirtname from StdDispatchunit a where trim(a.unitname) = '"+dataownerName.trim()+"'";
System.out.println("hql:"+hql);
QueryListObj obj = zdhSrapplicationDao.getQueryListByHql(hql);
if (obj == null) {
return "";
}
List list = obj.getElemList();
if (list == null || list.size() < 1){
return "";
}
//提取当前的数据所属单位的英文简称(BD、DD... ...)
String eshirtname = (String)list.iterator().next();
System.out.println("当前的数据所属单位的英文简称:"+eshirtname);
return eshirtname;
}
/**
* 提取当前的班号
*/
public String getOndutyno(){
//定义hql，以“接班时间”最大的为查询条件
String hql = "select a.ondutyno from ZdhAutoondutylog a where a.successiontime = (select max(b.successiontime) from ZdhAutoondutylog b)";
QueryListObj obj = zdhSrapplicationDao.getQueryListByHql(hql);
if (obj == null) {
return "";
}
List list = obj.getElemList();
if (list == null || list.size() < 1){
return "";
}
//提取当前的班号
String ondutyno = (String)list.iterator().next();
return ondutyno;
}
/**
* 生成传动记录(主管主任审批时调用,要同时区分是市调还是区调)
* @param dto
*
*/
public void genTransrecord(ZdhSrapplication zdhSrapplication){
ZdhTransrecordDto dto = new ZdhTransrecordDto();
//填写人
dto.setSys_fille(zdhSrapplication.getSys_fille());
//填写单位
dto.setSys_filldept(zdhSrapplication.getSys_filldept());
//填写时间
dto.setSys_filltime(null);
//数据所属单位
dto.setSys_dataowner(zdhSrapplication.getSys_dataowner());
//任务来源编号
dto.setSourcetaskno(zdhSrapplication.getFapplicationno());
dto.setTasksource(ZdhConstants.ZdhTransrecord_BUSINESS_REASON_ZDHSRAPP);
//厂站名称
dto.setFstationname(zdhSrapplication.getFstationname());
//传动内容说明
dto.setExplanation(zdhSrapplication.getFeqpclassname());
//传动原因
dto.setTransreason(ZdhConstants.ZdhTransrecord_BUSINESS_REASON_ZDHSRAPP);
//设置当前的班号
String ondutyno = this.getOndutyno();
ZdhAutoondutylogDto ondutylogDto = new ZdhAutoondutylogDto();
ondutylogDto.setOndutyno(ondutyno);
dto.setZzdhtransrecord3(ondutylogDto);
zdhTransrecordService.saveOrUpdateZdhTransrecord(dto);
}
/**
* 传动记录和停复役的对应关系
*/
public void genSrappToTransrecord (ZdhSrapplication zdhSrapplication,WorkflowHandleDto dto){
CtrlWflentityrel ctrlWflentityrel=new CtrlWflentityrel();
ctrlWflentityrel.setEntityid(zdhSrapplication.getFapplicationno());
ctrlWflentityrel.setEntityname(ZdhConstants.ZdhSrappl_BUSINESS_WORKSOURCE);
ctrlWflentityrel.setTaskid(dto.getTaskInstanceId());//当前任务id
ctrlWflentityrel.setFrelid(new SequenceCreator().getUID());
ctrlWflentityrelDao.saveOrUpdate(ctrlWflentityrel);
}
/**
* 根据申请单编号获取数据所属单位(在需要数据所属单位时调用该方法)
* @param id
* @return
*/
private String getSysDataownerById(String id){
ZdhSrapplicationDto dto = this.loadZdhSrapplication(id);
String dataowner = dto.getSys_dataowner();
System.out.println("getSysDataownerById数据所属单位:"+dataowner);
return dataowner;
}
/**
* 发送业务对象信息
* dto 工作流dto
* toFalg 接收方编号
*/
private void sendBussObj (WorkflowHandleDto dto,int toFalg,ZdhSrapplication zdhSrapplication) throws Exception {
/***********获取message.properties中的key值********************/
//发送方服务IP
String provider_url = MessageConfig.getValue("JNDI_PROVIDER_URL");
//发送方编码
String local_node = MessageConfig.getValue("LOCAL_NODE");
//接收方编码(以逗号隔开的)
String recv_queues = MessageConfig.getValue("RECV_QUEUE");
/*
//市局
String recv_queueForSJ = recv_queues.split(",")[0];
//城区
String recv_queueForCQ = recv_queues.split(",")[1];
*/
//模块名称(以逗号隔开的)
String modules = MessageConfig.getValue("MODULE");
//消息传递对象的包结构
String transDtoPackage = MessageConfig.getValue("transDtoPackage");
//业务对象的包结构
String bussDtoPackage = MessageConfig.getValue("bussDtoPackage");
//dozer映射文件的绝对路径
String mappingFileHome = MessageConfig.getValue("mappingFileHome");
/*************设置控制dto(ControlDto)的属性***************/
ControlDto controlDto = new ControlDto();
//设置发送方编码
controlDto.setFrom(local_node);
//设置接收方编码 此处无需设置
/*switch (toFalg) {
case 1:
//市局
controlDto.setTo("sj");
break;
case 2:
//城区
controlDto.setTo("cq");
break;
}
*/
//设置模块名 通过bussinessSign到数据库中获取，此处无需设置
//controlDto.setModule("");
//业务标识,需要到表MESSAGE_QNAME中进行查询 BUSS_SIGN字段
controlDto.setBussinessSign("ZdhSrapplication");
//通知内容:该信息是跟随esb消息发送时，需要发通知的内容.此项不为空，需要设置PersonDto的属性
controlDto.setNotifyContent("");
//中心任务Id
controlDto.setCenterTaskId(dto.getTaskId());
//二级单位任务Id
controlDto.setAreaTaskId("");
//类型 1-通知 2-公告 3-业务
controlDto.setType("3");
//版本 备用
controlDto.setContentVersion("");
//是否触发器 (就是自动触发某业务方法) 0 no 1 yes
controlDto.setIsTrigger("1");
//业务对象名称 applicationContext_dmis_service.xml中的service对应的id
controlDto.setObjectName("iZdhSrapplicationService");
//业务方法名称 具体的service类中所对应的方法
controlDto.setMethodName("recBussData");
//跟踪号 备用
controlDto.setTraceNumber("");
//发送时间 sendTime
java.sql.Timestamp sendTime = DateUtil.getCurrentTimestamp();
controlDto.setSendTime(sendTime.toString());
//接收时间
controlDto.setRecvTime("");
/*************设置接收方信息***************/
//到市局 start
RecvDto rdto = new RecvDto();
switch (toFalg) {
case 1:
//市局
rdto.setTo("sj");
break;
case 2:
//城区
rdto.setTo("cq");
break;
}
List recvDtos = new ArrayList();
recvDtos.add(rdto);
controlDto.setRecvDtos(recvDtos);//接收方信息RecvDto集合
/*设置附件*/
List attachments = new ArrayList();
AttachmentDto adto = new AttachmentDto();
byte[] bytes = zdhSrapplication.getFannexexplanation();
if (bytes.length < 1) {
adto.setContent(bytes);
adto.setId(dto.getBusId());
attachments.add(adto);
controlDto.setAttachments(attachments);//附件集合，List中均为AttachmentDto
}
/************业务DTO**************/
ZdhSrapplicationDto zdhSrapplicationDto = loadZdhSrapplication(dto.getBusId());
IexchangeService service = (IexchangeService) (new ExchangeServiceImpl());
/**************发送*************/
StopWatch stopwatch = new StopWatch();
stopwatch.start();
service.sendMessage(controlDto, zdhSrapplicationDto);
stopwatch.stop();
System.out.println("发送耗时: " + stopwatch.getTime());
}
/**
* 将接收的业务对象保存到本地的数据库
* @param obj
*/
public void recBussData (List list){
System.out.println("recBussData start:"+list.size());
ControlDto dto = (ControlDto) list.get(0);
ZdhSrapplicationDto zdhSrapplicationDto = (ZdhSrapplicationDto)list.get(1);
ZdhSrapplicationDto dto2 = new ZdhSrapplicationDto();
dto2.setFapplicationno(zdhSrapplicationDto.getFapplicationno());
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(zdhSrapplicationDto.getFapplicationno());
/*
if (zdhSrapplication != null) {
int version = zdhSrapplication.getVersion();
dto2.setVersion(version);
} else {
dto2.setVersion(0);
}
*/
dto2.setFapplicationono(zdhSrapplicationDto.getFapplicationono());
dto2.setFcenteropinion1(zdhSrapplicationDto.getFcenteropinion1());
dto2.setFattribute(zdhSrapplicationDto.getFattribute());
dto2.setFannexexplanation(zdhSrapplicationDto.getFannexexplanation());
dto2.setFapplicationendime(zdhSrapplicationDto.getFapplicationendime());
dto2.setFapplicationno(zdhSrapplicationDto.getFapplicationno());
dto2.setFapplicationstarttime(zdhSrapplicationDto.getFapplicationstarttime());
dto2.setFapplicationtype(zdhSrapplicationDto.getFapplicationtype());
dto2.setFapprovalendtime(zdhSrapplicationDto.getFapprovalendtime());
dto2.setFapprovalstarttime(zdhSrapplicationDto.getFapprovalstarttime());
dto2.setFcenteropinion2(zdhSrapplicationDto.getFcenteropinion2());
dto2.setFcenteropinion3(zdhSrapplicationDto.getFcenteropinion3());
dto2.setFeqpclassname(zdhSrapplicationDto.getFeqpclassname());
dto2.setFeqpclasstype(zdhSrapplicationDto.getFeqpclasstype());
dto2.setFexcutestatus(zdhSrapplicationDto.getFexcutestatus());
dto2.setSys_filltime(zdhSrapplicationDto.getSys_filltime());
//以下是测试使用
dto2.setFstatus("1");
dto2.setFexcutestatus("草稿");
dto2.setSys_dataowner("CQ");
this.saveOrUpdateZdhSrapplication(dto2);
String strentityId=zdhSrapplicationDto.getFapplicationno();
// String sql=" FROM CtrlWflentityrel as ctlwf where ctlwf.entityid='"+strentityId+"'";
// QueryListObj obj=zdhSrapplicationDao.getQueryListByHql(sql);
// List ctlList=obj.getElemList();
// Iterator ctlit= ctlList.iterator();
// if(ctlit.hasNext())
// {
// CtrlWflentityrel ctrlWflentityrel=(CtrlWflentityrel)ctlit.next();
// long taskId=new Long(ctrlWflentityrel.getTaskid()).longValue();
// workFlowDao.endWaitingByTaskInstance(taskId);
// ZdhSrapplication zdhSrapplication=zdhSrapplicationDao.findByPk(strentityId);
// //椹冲洖
// zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_STATUS_NEW);
// zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_BUSINESS_AREA_MODI);
// //纭
// zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_STATUS_NEW);
// zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_BUSINESS_AREA_APPROVED);
// zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
//
// }
//淇濆瓨闄勪欢(blob绫诲瀷鐨勬暟鎹?
//鎺у埗dto,绗竴涓厓绱犲瓨鏀炬帶鍒禿to
//鑾峰彇闄勪欢
// List attachments = dto.getAttachments();
// AttachmentDto adto = (AttachmentDto) attachments.get(0);
// zdhSrapplicationDto.setFannexexplanation(adto.getContent());
// System.out.println("@@@@@@@"+adto.getContent());
// this.saveOrUpdateZdhSrapplication(zdhSrapplicationDto);
}
/*******************************工作流***********************************/
/**
* 启动
*/
public void start(WorkflowHandleDto dto) throws DataAccessException {
//根据数据所属单位进行控制
String dataowner = getSysDataownerById(dto.getBusId());
if (dataowner.equalsIgnoreCase("") || dataowner == null || dataowner == "") {
System.out.println("未能获取数据所属单位");
return;
}
int iReturn = zdhSrapplicationWFServiceImpl.start(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_BDGS.indexOf(dataowner.toUpperCase()) >= 0) {
/***********变电公司********************/
//设置流转状态为"变电公司专工审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDSPECAPPROVE);
//设置业务状态为"审核中"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_QD.indexOf(dataowner.toUpperCase()) >= 0) {
/***********区调********************/
//设置流转状态为"自动化专工审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SPECAPPROVE);
//设置业务状态为"审核中"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_ZDHYXC.indexOf(dataowner.toUpperCase()) >= 0) {
/*************自动化运行处*******************/
//设置流转状态为"自动化运行处处长审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_ZDHRUNAPPROVE);
//设置业务状态为"审核中"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
}
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 变电公司自动化专工审批 2
*/
public void zdhSrapplBdspecApprove(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplBdspecApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/******变电公司自动化专工审批不通过*******/
//设置流转状态为"变电运行单位修改申请"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDRUNMODIFY);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
break;
case 1:
/*****变电公司自动化专工审批通过******/
//设置流转状态 为"变电公司领导审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDHEADERAPPROVE);
//设置业务状态为审核中
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
break;
}
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 变电运行单位修改申请
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplBdrunModify(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplBdrunModify(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//设置流转状态 为"变电公司自动化专工审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDSPECAPPROVE);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 变电公司领导审批 4
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplBdheaderApprove(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplBdheaderApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/*********审批不通过*************/
//设置流转状态 为"变电运行单位修改申请"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDRUNMODIFY);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
break;
case 1:
/*********审批通过*************/
//设置流转状态 为"自动化专工审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SPECAPPROVE);
//设置业务状态为"审核中"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
break;
}
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 自动化运行处处长审批
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplZdhrunApprove(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplZdhrunApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//设置流转状态 为自动化专工审批
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SPECAPPROVE);
//设置业务状态为审核中
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 自动化运行处修改(自动化运行处修改申请)
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplZdhrunModify(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplZdhrunModify(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//设置流转状态 为自动化运行处处长审批
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_ZDHRUNAPPROVE);
//设置业务状态为审核中
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 变电自动化专工任务下发 7
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplBdrunTasksent(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplBdrunTasksent(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//停役性质
String fattribute = zdhSrapplication.getFattribute().trim();
if (fattribute.equalsIgnoreCase(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsWorkType_CHECK)) {
/**********检修**********/
//生成传动记录
this.genTransrecord(zdhSrapplication);
//生成传动记录和停复役的对应关系
this.genSrappToTransrecord(zdhSrapplication,dto);
//设置流转状态为"运行单位执行"
//zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_RUNEXEC);
//设置业务状态为"等待传动记录"
//zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_WAITTRANS);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
} else if (fattribute.equalsIgnoreCase(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsWorkType_REBACK)) {
/**********退运**********/
//设置流转状态为"运行单位执行"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_RUNEXEC);
//设置业务状态为"已报上级调度"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_REPSUPERIOR);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
}
/**
* 运行单位执行 8
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplRunExec(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplRunExec(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//设置流转状态为"专工归档"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SPECKEEPON);
//设置业务状态为"已执行"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_EXECUTED);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 下发审批结果
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplSentResult(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplSentResult(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
try{
//设置业务状态为"中调审批未通过"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_MidApprove_NO);
//设置流转状态为"新建"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_STATUS_NEW);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
///发送业务对象
sendBussObj(dto,2,zdhSrapplication);
} catch (Exception e){
e.printStackTrace();
}
}
/**
* 主任审批(运维中心主任审批)
*/
public void zdhSrapplDirectorApprove(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplDirectorApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/******运维中心主任审批不通过*******/
//设置流转状态为自动化专工下发未批准意见
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SENTCOMMENT);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
case 1:
/*****运维中心主任审批通过******/
//设置流转状态为"处长审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_HEADERAPPROVE);
//设置业务状态为"审核中"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
}
}
/**
* 主管主任审批 11
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplMDicrecterApprove(WorkflowHandleDto dto) throws DataAccessException {
//根据数据所属单位进行控制
String dataowner = getSysDataownerById(dto.getBusId());
if (dataowner.equalsIgnoreCase("") || dataowner == null || dataowner == "") {
System.out.println("未能获取数据所属单位");
return;
}
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplMDicrecterApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//停役性质
String fattribute = zdhSrapplication.getFattribute().trim();
//审批通过标志
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/******主管主任审批不通过*******/
//设置流转状态为自动化专工下发未批准意见
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SENTCOMMENT);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
case 1:
/*****主管主任审批通过******/
if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_BDGS.indexOf(dataowner.toUpperCase()) >= 0) {
/************变电公司**************/
//设置流转状态为"变电自动化专工任务下发"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDTASKSENT);
//设置业务状态为"下发执行"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_EXECUTING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_QD.indexOf(dataowner.toUpperCase()) >= 0) {
/*********区调*************/
System.out.println("主管主任审批通过,下发批准信息... ...");
try{
//设置业务状态为"审批通过"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_MidApprove_YES);
//设置流转状态为区调的"自动化专工任务下发",为了触发区调的工作流
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_AREA_STATUS_SPECTASKSENT);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
sendBussObj(dto,2,zdhSrapplication);
} catch (Exception e){
e.printStackTrace();
}
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_ZDHYXC.indexOf(dataowner.toUpperCase()) >= 0) {
/****************自动化运行处********************/
if (fattribute.equalsIgnoreCase(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsWorkType_CHECK)) {
/**********检修**********/
//设置流转状态为"运行单位执行"
//zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_RUNEXEC);
//设置业务状态为"等待传动记录"
//zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_WAITTRANS);
//生成传动记录
this.genTransrecord(zdhSrapplication);
//生成传动记录和停复役的对应关系
this.genSrappToTransrecord(zdhSrapplication,dto);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
} else if (fattribute.equalsIgnoreCase(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsWorkType_REBACK)){
/**********退运**********/
//设置流转状态为"运行单位执行"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_RUNEXEC);
//设置业务状态为"已报上级调度"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_REPSUPERIOR);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
}
break;
}
}
/**
* 将审批意见下发(自动化专工下发未批准意见)
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplSentComment(WorkflowHandleDto dto) throws DataAccessException {
//根据数据所属单位进行控制
String dataowner = getSysDataownerById(dto.getBusId());
if (dataowner.equalsIgnoreCase("") || dataowner == null || dataowner == "") {
System.out.println("未能获取数据所属单位");
return;
}
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplSentComment(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_BDGS.indexOf(dataowner.toUpperCase()) >= 0) {
/**********变电公司***************/
//设置流转状态为"变电运行单位修改申请"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_BDRUNMODIFY);
//设置业务状态为"审核驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_ZDHYXC.indexOf(dataowner.toUpperCase()) >= 0){
/**********自动化运行处***************/
//设置流转状态为"自动化运行处修改申请"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_ZDHRUNMODIFY);
//设置业务状态为"审核驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
} else if (ZdhConstants.ZdhSrappl_WORKFLOW_CITY_IsDpt_QD.indexOf(dataowner.toUpperCase()) >= 0) {
/**********区调 自动下发审批结果********/
System.out.println("自动化专工下发未批准意见... ...");
try{
sendBussObj(dto,2,zdhSrapplication);
} catch (Exception e){
e.printStackTrace();
}
}
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
}
/**
* 自动化专工审批 13
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplSpecApprove(WorkflowHandleDto dto) throws DataAccessException {
System.out.println("workflow taskid is:"+dto.getTaskInstanceId());
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplSpecApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/******自动化专工审批不通过*******/
//设置流转状态为自动化专工下发未批准意见
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SENTCOMMENT);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
case 1:
/*****自动化专工审批通过******/
//设置流转状态为"运维中心主任审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_DIRECTORAPPROVE);
//设置业务状态为审核中
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
}
}
/**
* 专工归档 14
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplSpecKeepon(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplSpecKeepon(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
//设置流转状态为"结束"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_OVER);
//设置业务状态为"已归档"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_CONFORMED);
}
/**
* 处长审批 15
* @param dto
* @throws DataAccessException
*/
public void zdhSrapplHeaderApprove(WorkflowHandleDto dto) throws DataAccessException {
int iReturn = zdhSrapplicationWFServiceImpl.zdhSrapplHeaderApprove(dto);
ZdhSrapplication zdhSrapplication = zdhSrapplicationDao.findByPk(dto.getBusId());
String transitionFlag = dto.getTransitionFlag();
switch (Integer.valueOf(transitionFlag).intValue()) {
case -1:
/******处长审批不通过*******/
//设置流转状态为自动化专工下发未批准意见
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_SENTCOMMENT);
//设置业务状态为"审批驳回"
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_BdspecApprove_TRANSIT_NO);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
case 1:
/*****处长审批通过******/
//设置流转状态为"主管主任审批"
zdhSrapplication.setFstatus(ZdhConstants.ZdhSrappl_WORKFLOW_CITY_STATUS_MDICRECTERAPPROVE);
//设置业务状态为审核中
zdhSrapplication.setFexcutestatus(ZdhConstants.ZdhSrappl_BUSINESS_CITY_APPROVING);
zdhSrapplicationDao.saveOrUpdate(zdhSrapplication);
break;
}
}
}
| [
"[email protected]"
] | |
eb0cac9f70f6b4ae820bf1e0285414543fdc3cf5 | 302b078d1066df071f1e21060623d93d1ab66c89 | /service/src/main/java/com/gmail/kurmazpavel/CmdListOrders.java | 25a7e87214214dabdda811bd7c9d517c4e120e4c | [] | no_license | PavelKurmaz/JD02 | 58ce039bba6022b5f55ffd6a90c71dad68686da5 | d51cb76044819ddbca6065b818c2b975413ed29b | refs/heads/master | 2020-03-27T09:29:49.173096 | 2018-08-27T20:02:38 | 2018-08-27T20:02:38 | 146,345,517 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,059 | java | package com.gmail.kurmazpavel;
import com.gmail.kurmazpavel.DAO.DAO;
import com.gmail.kurmazpavel.beans.Order;
import com.gmail.kurmazpavel.beans.User;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.sql.SQLException;
import java.util.List;
import java.util.Locale;
class CmdListOrders extends Cmd {
@Override
ActionResult execute(HttpServletRequest req, HttpServletResponse resp) throws SQLException {
if (Util.isPost(req)){
return new ActionResult(Actions.PROFILE);
}
HttpSession session = req.getSession();
Object object = session.getAttribute("user");
if (object != null){
User user = (User) object;
int user_id = (int) user.getId();
String where = String.format(Locale.US, "WHERE users_ID='%d'", user_id);
List<Order> orders = DAO.getDao().order.getAll(where);
req.setAttribute("orders", orders);
}
return null;
}
}
| [
"[email protected]"
] | |
320999efec7c095025ffccc91a2c923e1f8b05fe | 63fb48637ecc43886a2d90ca4533063d147a6605 | /src/main/java/com/it/wechatorder/service/impl/SeckillServiceImpl.java | ccda675b7941aaaa1e76ea9fb94654373a9393b5 | [] | no_license | XialinKR/wechatorder | 050f801c990f4e1f1070ed02098399c9965d0250 | 6e08a80374e62459b63d3ebec934e6c44d6c7860 | refs/heads/master | 2022-06-24T04:01:58.523443 | 2020-02-19T15:11:53 | 2020-02-19T15:11:53 | 192,267,407 | 0 | 0 | null | 2022-06-17T02:13:51 | 2019-06-17T03:15:35 | Java | UTF-8 | Java | false | false | 1,359 | java | package com.it.wechatorder.service.impl;
import com.it.wechatorder.domain.ProductInfo;
import com.it.wechatorder.enums.ResultEnum;
import com.it.wechatorder.exception.SellException;
import com.it.wechatorder.service.ProductService;
import com.it.wechatorder.service.RedisLock;
import com.it.wechatorder.service.SeckillService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class SeckillServiceImpl implements SeckillService{
//超时时间
private static final Long TIMEOUT= 3*1000L;
@Autowired
private RedisLock redisLock;
@Autowired
private ProductService productService;
@Override
public void seckillByProductId(String productId,Integer stock) {
ProductInfo productInfo = productService.findOne(productId);
if (productInfo==null){
throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);
}
Long time = System.currentTimeMillis()+TIMEOUT;
redisLock.lock(productId, String.valueOf(time));
if (productInfo.getProductStock()==0){
throw new SellException(100,"活动结束");
}
productInfo.setProductStock(productInfo.getProductStock()-1);
productService.saveOrUpdate(productInfo);
redisLock.unlock(productId, String.valueOf(time));
}
}
| [
"[email protected]"
] | |
44e7ed1ab19eb368e96ccd4184172559f67e5a1b | 507a448f68e6f0ff562cf511aa9df39510e70a66 | /1.7.10/main/java/com/Aarron/WallpaperCraft/Blocks/TestCarpet.java | 769eea4766764d1f51ea00255376d03de1bf3d34 | [] | no_license | p455w0rd/WallpaperCraft | 80127b52b83137ea1e6340676fa64d607331002a | e323680a34fbd1eef8d0c5467bd01bcf5b085e86 | refs/heads/master | 2020-07-02T23:59:32.473876 | 2016-11-19T14:31:59 | 2016-11-19T14:31:59 | 74,213,065 | 0 | 0 | null | 2016-11-19T14:22:14 | 2016-11-19T14:22:14 | null | UTF-8 | Java | false | false | 4,391 | java | package com.Aarron.WallpaperCraft.Blocks;
import java.util.List;
import com.Aarron.WallpaperCraft.Main;
import com.Aarron.WallpaperCraft.CreativeTab.Tab;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraft.block.Block;
public class TestCarpet extends Block {
public IIcon[] icons = new IIcon[15];
public TestCarpet(String unlocalizedName, Material material) {
super(material);
this.setBlockName("TestCarpet");
this.setHardness(1.25F);
this.setResistance(6.0F);
this.setHarvestLevel("pickaxe", 0);
this.setStepSound(soundTypeWood);
this.setCreativeTab(Tab.WPtab);
}
@SideOnly(Side.CLIENT)
public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int face)
{
return face == 1 ? true : super.shouldSideBeRendered(world, x, y, z, face);
}
// Can this block stay at this position. Similar to canPlaceBlockAt except gets checked often with plants.
public boolean canBlockStay(World world, int x, int y, int z)
{
return !world.isAirBlock(x, y - 1, z);
}
/**
* Sets the block's bounds for rendering it as an item
*/
public void setBlockBoundsForItemRender()
{
this.func_150089_b(0);
}
/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
* their own) Args: x, y, z, neighbor Block
*/
public void onNeighborBlockChange(World world, int x, int y, int z, Block face)
{
this.func_150090_e(world, x, y, z);
}
private boolean func_150090_e(World world, int x, int y, int z)
{
if (!this.canBlockStay(world, x, y, z))
{
this.dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
world.setBlockToAir(x, y, z);
return false;
}
else
{
return true;
}
}
/**
* Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
*/
public boolean canPlaceBlockAt(World wolrd, int x, int y, int z)
{
return super.canPlaceBlockAt(wolrd, x, y, z) && this.canBlockStay(wolrd, x, y, z);
}
/**
* Updates the blocks bounds based on its current state. Args: world, x, y, z
*/
public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z)
{
this.func_150089_b(world.getBlockMetadata(x, y, z));
}
protected void func_150089_b(int p_150089_1_)
{
byte b0 = 0;
float f = (float)(1 * (1 + b0)) / 16.0F;
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, f, 1.0F);
}
public boolean renderAsNormalBlock()
{
return false;
}
public boolean isOpaqueCube()
{
return false;
}
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
{
byte b0 = 0;
float f = 0.0625F;
return AxisAlignedBB.getBoundingBox((double)x + this.minX, (double)y + this.minY, (double)z + this.minZ, (double)x + this.maxX, (double)((float)y + (float)b0 * f), (double)z + this.maxZ);
}
@Override //Sets how many variations there are
public IIcon getIcon(int side, int meta) {
if (meta > 15)
meta = 0;
return this.icons[meta];
}
@Override //Registers the textures for each block. This is where I set the texture name.
public void registerBlockIcons(IIconRegister reg) {
for (int i = 0; i < 15; i ++) {
this.icons[i] = reg.registerIcon("wp:DiagonallyDottedBlue-" + i);
}
}
@Override //Makes it so that the block dropped has a meta value equal to the block broken
public int damageDropped(int meta) {
return meta;
}
@Override //Tells Minecraft to assign a creative tab for each meta value of the block
public void getSubBlocks(Item item, CreativeTabs tab, List list) {
for (int i = 0; i < 15; i ++) {
list.add(new ItemStack(item, 1, i));
}
}
} | [
"Aarron@gmail"
] | Aarron@gmail |
ffbe7f8f1f58c5946695a61d102ef019924fe795 | 95ee91ab0d5bcd0250f6588a7e47ecfdb9bdee7f | /java/day07/ExpressionConversion.java | 9d93bb1c61f96570b1fa2701ce284bffa65e2f92 | [] | no_license | AbbyBounty/DS | cec15524c7b4968a47583cb595d572722b47c3ed | 3c36424bb33e841c617fcc8ea2ca37ed34fb453f | refs/heads/master | 2022-11-28T19:33:20.555359 | 2020-08-07T05:14:13 | 2020-08-07T05:14:13 | 263,121,281 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,311 | java | import java.util.Arrays;
import java.util.Collections;
import java.util.Stack;
class ExpressionConversion {
public static int pri(char op) {
switch (op)
{
case '$': return 10;
case '*': return 7;
case '/': return 7;
case '+': return 2;
case '-': return 2;
}
return 0;
}
public static int calc(int a, int b, char op) {
switch (op)
{
case '$': return (int)Math.pow(a, b);
case '*': return a * b;
case '/': return a / b;
case '+': return a + b;
case '-': return a - b;
}
return 0;
}
public static String infix_to_postfix(String infix) {
int i, k = 0;
char in[] = infix.toCharArray();
char post[] = new char[in.length];
//0. create stack of operator
Stack<Character> s = new Stack<>();
//1. process each sym in infix from left to right
for (i = 0; i < in.length; i++) {
//2. if sym in operand, append to postfix string
if (Character.isDigit(in[i]))
post[k++] = in[i];
//4. if opening '(', push on stack.
else if (in[i] == '(')
s.push(in[i]);
//5. if closing ')', pop all ops from stack and append to postfix until '(' is found on stack. Also pop & discard '(' from stack.
else if (in[i] == ')') {
while (s.peek() != '(') {
post[k++] = s.pop();
}
s.pop();
}
//3. if sym is operator, push on the stack.
else { // operator
//3a. can push current op only if its priority is higher than topmost op in stack.
//3b. if priority of topmost op is greater or equal, pop it and append to postfix.
while (!s.empty() && pri(s.peek()) >= pri(in[i])) {
post[k++] = s.pop();
}
s.push(in[i]);
}
}
//6. at the end pop all ops from stack and append to postfix.
while (!s.empty()) {
post[k++] = s.pop();
}
post[k] = '\0';
return new String(post, 0, k);
}
public static String infix_to_prefix(String infix) {
int i, k = 0;
char in[] = infix.toCharArray();
char pre[] = new char[in.length];
//0. create stack of operator
Stack<Character> s = new Stack<>();
//1. process each sym in infix from right to left
for (i = in.length-1; i>=0; i--) {
//2. if sym in operand, append to prefix string
if (Character.isDigit(in[i]))
pre[k++] = in[i];
//4. if closing ')', push on stack.
else if (in[i] == ')')
s.push(in[i]);
//5. if opening '(', pop all ops from stack and append to prefix until ')' is found on stack. Also pop & discard ')' from stack.
else if (in[i] == '(') {
while (s.peek() != ')') {
pre[k++] = s.pop();
}
s.pop();
}
//3. if sym is operator, push on the stack.
else { // operator
//3a. can push current op only if its priority is higher or equal than topmost op in stack.
//3b. if priority of topmost op is greater, pop it and append to prefix.
while (!s.empty() && pri(s.peek()) > pri(in[i])) {
pre[k++] = s.pop();
}
s.push(in[i]);
}
}
//6. at the end pop all ops from stack and append to prefix.
while (!s.empty()) {
pre[k++] = s.pop();
}
pre[k] = '\0';
//7. reverse the prefix string
return new StringBuilder(new String(pre, 0, k)).reverse().toString();
}
public static int postfix_eval(String postfix) {
char post[] = postfix.toCharArray();
//0. create stack of operands
Stack<Integer> s = new Stack<>();
//1. process sym in postfix from left to right
for (int i = 0; i < post.length; i++) {
//2. if operand is found, push on stack
if (Character.isDigit(post[i]))
s.push(post[i] - '0'); // '5' != 5
//3. if operator is found, pop two values from stack, calc result and push it on stack
else {
int b = s.pop();
int a = s.pop();
int r = calc(a, b, post[i]);
s.push(r);
}
}
//4. at the end, pop last value from stack & return (result)
int r = s.pop();
return r;
}
public static int prefix_eval(String prefix) {
char pre[] = prefix.toCharArray();
//0. create stack of operands
Stack<Integer> s = new Stack<>();
//1. process sym in prefix from right to left
for (int i = pre.length-1; i >= 0; i--) {
//2. if operand is found, push on stack
if (Character.isDigit(pre[i]))
s.push(pre[i] - '0'); // '5' != 5
//3. if operator is found, pop two values from stack, calc result and push it on stack
else {
int a = s.pop();
int b = s.pop();
int r = calc(a, b, pre[i]);
s.push(r);
}
}
//4. at the end, pop last value from stack & return (result)
int r = s.pop();
return r;
}
public static void main(String[] args) {
String infix = "5+9-4*(8-6/2)+1$(7-3)";
String postfix = "", prefix = "";
int res;
System.out.println("infix : " + infix);
postfix = infix_to_postfix(infix);
System.out.println("postfix : " + postfix);
res = postfix_eval(postfix);
System.out.println("Postfix Result: " + res);
prefix = infix_to_prefix(infix);
System.out.println("prefix : " + prefix);
res = prefix_eval(prefix);
System.out.println("Prefix Result: " + res);
}
}
| [
"[email protected]"
] | |
e10b4537a4a7518a5d9de744c4004098fd6634aa | 298303612eaa07e2518cc9148a00258e6273be33 | /src/main/java/pwr/chrzescijanek/filip/dataminer/RuleEvaluatorFactory.java | 6b7fc4480e8b2382160a038add983eb56b7d4aac | [] | no_license | FilipChrzescijanek/basic-dataminer | 975f82508fee1633fe68e50de439051c1b442cef | a45889544d4fc9c09a3b64d194e80266b1d3ab08 | refs/heads/master | 2021-06-27T13:24:19.392348 | 2017-09-14T17:45:51 | 2017-09-14T17:45:51 | 103,562,694 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 409 | java | package pwr.chrzescijanek.filip.dataminer;
import com.bpodgursky.jbool_expressions.Expression;
import java.util.List;
public class RuleEvaluatorFactory {
private final List<Stats> statistics;
public RuleEvaluatorFactory(final List<Stats> statistics) {this.statistics = statistics;}
public RuleEvaluator getEvaluator(final Expression<String> rule) {
return new RuleEvaluator(statistics, rule);
}
}
| [
"[email protected]"
] | |
1ee37bb4f447569a27165e2d2c7978cf5a6012c6 | fc663bf949a3da06a7658d5bc7c07b8dbe40b595 | /ArrayExamples/src/Array2DExample1.java | b3176c3b0de9092aea24411492576e18a9b250d4 | [
"MIT"
] | permissive | mcadventurecity/AP-CSA-2018-Jarod | 0445ceb4c6aac06688e19c07beac1c4a5536dcc3 | 70f8324045143dc290767a727fd9d37c924da341 | refs/heads/master | 2020-03-18T22:13:22.850476 | 2018-05-30T20:19:23 | 2018-05-30T20:19:23 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 341 | java |
public class Array2DExample1 {
public static void main(String[] args) {
int[][] arr = {{1, 2, 3, 1337, 999},{4, 5, 6}, {7, 8, 9}, {10, 11, 12, 666}, {13, 14, 15}};
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.print("\n");
}
}
}
| [
"[email protected]"
] | |
33c4228afcee3d6967a6e239cb1f4e21d4b6c4b6 | 247b577f453bfdb0965942b7d0806927fb07ddea | /first project/src/launcher/TestApp.java | 610d08682548cc51203d10648fddeb4e995d4d1f | [] | no_license | pedrovlmartins/Distributed-Systems-SDIS | fa853bbf3bbbf5be2d154a87fd3ef09ccef3bd4c | edfdc981c1f52c4f1f0081273e4095932bd565fb | refs/heads/master | 2020-03-11T17:25:06.231247 | 2018-04-20T17:33:08 | 2018-04-20T17:33:08 | 130,146,311 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,808 | java | package launcher;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Arrays;
public class TestApp {
static DatagramSocket socket;
private static InetAddress address;
private static int portNumber;
public static void main(String[] args) throws SocketException {
if (args.length < 2) {
System.out.println("Wrong usage! Usage: java launcher.TestApp <peer_ap> <sub_protocol> <opnd_1> <opnd_2> ");
System.out.println("Exiting...");
return;
}
socket = new DatagramSocket();
getSocketInfo(args[0]);
String[] commands = Arrays.copyOfRange(args, 1, args.length);
StringBuilder builder = new StringBuilder();
for(String s : commands) {
builder.append(s + " ");
}
byte[] buf = builder.toString().getBytes();
DatagramPacket packet = new DatagramPacket(buf, buf.length, address, portNumber);
try {
socket.send(packet);
} catch (IOException e) {
System.out.println("Could not send the packet");
}
}
private static void getSocketInfo(String string) {
if (string.contains(":")) {
String[] info = string.split(":");
if (info.length == 1) {
getLocalHost(Integer.parseInt(info[1]));
} else if (info.length == 2) {
try {
address = InetAddress.getByName(info[1]);
} catch (UnknownHostException e) {
System.out.println("Could not get host: " + info[1]);
}
portNumber = Integer.parseInt(info[2]);
}
} else {
getLocalHost(Integer.parseInt(string));
}
}
private static void getLocalHost(int port) {
portNumber = port;
try {
address = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
System.out.println("Could not get localhost");
}
}
}
| [
"[email protected]"
] | |
c05b440169071c4248775d9535e9bd16de4eafd0 | 254292bbb95222cd6a97eae493e28b5a63c14a9d | /spring-boot/src/test/java/org/springframework/boot/bind/RelaxedDataBinderTests.java | 84f74b7a105febefb7b29536f74512442caa8bed | [
"Apache-2.0"
] | permissive | pikefeier/springboot | 0e881a59ceefd3ae1991e83a0ad4a4d787831097 | 2fb23ab250f095dec39bf5e4d114c26d51467142 | refs/heads/master | 2023-01-09T02:51:23.939848 | 2019-12-30T12:19:14 | 2019-12-30T12:19:14 | 230,909,567 | 0 | 0 | Apache-2.0 | 2022-12-27T14:51:00 | 2019-12-30T12:10:46 | Java | UTF-8 | Java | false | false | 34,538 | java | /*
* Copyright 2012-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.bind;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.validation.Constraint;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Payload;
import javax.validation.constraints.NotNull;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.NotWritablePropertyException;
import org.springframework.context.support.StaticMessageSource;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.validation.BindingResult;
import org.springframework.validation.DataBinder;
import org.springframework.validation.FieldError;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RelaxedDataBinder}.
*
* @author Dave Syer
* @author Phillip Webb
* @author Stephane Nicoll
*/
public class RelaxedDataBinderTests {
@Rule
public ExpectedException expected = ExpectedException.none();
private ConversionService conversionService;
@Test
public void testBindString() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "foo: bar");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindChars() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "bar: foo");
assertThat(new String(target.getBar())).isEqualTo("foo");
}
@Test
public void testBindStringWithPrefix() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "test.foo: bar", "test");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindStringWithPrefixDotSuffix() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "some.test.foo: bar", "some.test.");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindFromEnvironmentStyleWithPrefix() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "TEST_FOO: bar", "test");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindToCamelCaseFromEnvironmentStyleWithPrefix() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "TEST_FOO_BAZ: bar", "test");
assertThat(target.getFooBaz()).isEqualTo("bar");
}
@Test
public void testBindToCamelCaseFromEnvironmentStyle() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "test.FOO_BAZ: bar", "test");
assertThat(target.getFooBaz()).isEqualTo("bar");
}
@Test
public void testBindFromEnvironmentStyleWithNestedPrefix() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "TEST_IT_FOO: bar", "test.it");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindCapitals() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "FOO: bar");
assertThat(target.getFoo()).isEqualTo("bar");
}
@Test
public void testBindUnderscoreInActualPropertyName() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "foo-bar: bar");
assertThat(target.getFoo_bar()).isEqualTo("bar");
}
@Test
public void testBindUnderscoreToCamelCase() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "foo_baz: bar");
assertThat(target.getFooBaz()).isEqualTo("bar");
}
@Test
public void testBindHyphen() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "foo-baz: bar");
assertThat(target.getFooBaz()).isEqualTo("bar");
}
@Test
public void testBindCamelCase() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "fooBaz: bar");
assertThat(target.getFooBaz()).isEqualTo("bar");
}
@Test
public void testBindNumber() throws Exception {
VanillaTarget target = new VanillaTarget();
bind(target, "foo: bar\n" + "value: 123");
assertThat(target.getValue()).isEqualTo(123);
}
@Test
public void testSimpleValidation() throws Exception {
ValidatedTarget target = new ValidatedTarget();
BindingResult result = bind(target, "");
assertThat(result.getErrorCount()).isEqualTo(1);
}
@Test
public void testRequiredFieldsValidation() throws Exception {
TargetWithValidatedMap target = new TargetWithValidatedMap();
BindingResult result = bind(target, "info[foo]: bar");
assertThat(result.getErrorCount()).isEqualTo(2);
for (FieldError error : result.getFieldErrors()) {
System.err.println(
new StaticMessageSource().getMessage(error, Locale.getDefault()));
}
}
@Test
public void testAllowedFields() throws Exception {
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, null);
binder.setAllowedFields("foo");
binder.setIgnoreUnknownFields(false);
BindingResult result = bind(binder, target,
"foo: bar\n" + "value: 123\n" + "bar: spam");
assertThat(target.getValue()).isEqualTo(0);
assertThat(target.getFoo()).isEqualTo("bar");
assertThat(result.getErrorCount()).isEqualTo(0);
}
@Test
public void testDisallowedFields() throws Exception {
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, null);
// Disallowed fields are not unknown...
binder.setDisallowedFields("foo", "bar");
binder.setIgnoreUnknownFields(false);
BindingResult result = bind(binder, target,
"foo: bar\n" + "value: 123\n" + "bar: spam");
assertThat(target.getValue()).isEqualTo(123);
assertThat(target.getFoo()).isNull();
assertThat(result.getErrorCount()).isEqualTo(0);
}
@Test
public void testBindNested() throws Exception {
TargetWithNestedObject target = new TargetWithNestedObject();
bind(target, "nested.foo: bar\n" + "nested.value: 123");
assertThat(target.getNested().getValue()).isEqualTo(123);
}
@Test
public void testBindRelaxedNestedValue() throws Exception {
TargetWithNestedObject target = new TargetWithNestedObject();
bind(target, "nested_foo_Baz: bar\n" + "nested_value: 123");
assertThat(target.getNested().getFooBaz()).isEqualTo("bar");
assertThat(target.getNested().getValue()).isEqualTo(123);
}
@Test
public void testBindRelaxedNestedCamelValue() throws Exception {
TargetWithNestedObject target = new TargetWithNestedObject();
bind(target, "another_nested_foo_Baz: bar\n" + "another-nested_value: 123");
assertThat(target.getAnotherNested().getFooBaz()).isEqualTo("bar");
assertThat(target.getAnotherNested().getValue()).isEqualTo(123);
}
@Test
public void testBindNestedWithEnvironmentStyle() throws Exception {
TargetWithNestedObject target = new TargetWithNestedObject();
bind(target, "nested_foo: bar\n" + "nested_value: 123");
assertThat(target.getNested().getValue()).isEqualTo(123);
}
@Test
public void testBindNestedList() throws Exception {
TargetWithNestedList target = new TargetWithNestedList();
bind(target, "nested[0]: bar\nnested[1]: foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindNestedListOfBean() throws Exception {
TargetWithNestedListOfBean target = new TargetWithNestedListOfBean();
bind(target, "nested[0].foo: bar\nnested[1].foo: foo");
assertThat(target.getNested().get(0).getFoo()).isEqualTo("bar");
}
@Test
public void testBindNestedListOfBeanWithList() throws Exception {
TargetWithNestedListOfBeanWithList target = new TargetWithNestedListOfBeanWithList();
bind(target, "nested[0].nested[0].foo: bar\nnested[1].nested[0].foo: foo");
assertThat(target.getNested().get(0).getNested().get(0).getFoo())
.isEqualTo("bar");
}
@Test
public void testBindNestedListCommaDelimitedOnly() throws Exception {
TargetWithNestedList target = new TargetWithNestedList();
this.conversionService = new DefaultConversionService();
bind(target, "nested: bar,foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindNestedSetCommaDelimitedOnly() throws Exception {
TargetWithNestedSet target = new TargetWithNestedSet();
this.conversionService = new DefaultConversionService();
bind(target, "nested: bar,foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test(expected = NotWritablePropertyException.class)
public void testBindNestedReadOnlyListCommaSeparated() throws Exception {
TargetWithReadOnlyNestedList target = new TargetWithReadOnlyNestedList();
this.conversionService = new DefaultConversionService();
bind(target, "nested: bar,foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindNestedReadOnlyListIndexed() throws Exception {
TargetWithReadOnlyNestedList target = new TargetWithReadOnlyNestedList();
this.conversionService = new DefaultConversionService();
bind(target, "nested[0]: bar\nnested[1]:foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindDoubleNestedReadOnlyListIndexed() throws Exception {
TargetWithReadOnlyDoubleNestedList target = new TargetWithReadOnlyDoubleNestedList();
this.conversionService = new DefaultConversionService();
bind(target, "bean.nested[0]:bar\nbean.nested[1]:foo");
assertThat(target.getBean().getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindNestedReadOnlyCollectionIndexed() throws Exception {
TargetWithReadOnlyNestedCollection target = new TargetWithReadOnlyNestedCollection();
this.conversionService = new DefaultConversionService();
bind(target, "nested[0]: bar\nnested[1]:foo");
assertThat(target.getNested().toString()).isEqualTo("[bar, foo]");
}
@Test
public void testBindNestedMap() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested.foo: bar\n" + "nested.value: 123");
assertThat(target.getNested().get("value")).isEqualTo("123");
}
@Test
public void testBindNestedMapPropsWithUnderscores() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested_foo: bar\n" + "nested_value: 123");
assertThat(target.getNested().get("value")).isEqualTo("123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
}
@Test
public void testBindNestedUntypedMap() throws Exception {
TargetWithNestedUntypedMap target = new TargetWithNestedUntypedMap();
bind(target, "nested.foo: bar\n" + "nested.value: 123");
assertThat(target.getNested().get("value")).isEqualTo("123");
}
@Test
public void testBindNestedMapOfString() throws Exception {
TargetWithNestedMapOfString target = new TargetWithNestedMapOfString();
bind(target, "nested.foo: bar\n" + "nested.value.foo: 123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
assertThat(target.getNested().get("value.foo")).isEqualTo("123");
}
@Test
public void testBindNestedMapOfStringWithUnderscore() throws Exception {
TargetWithNestedMapOfString target = new TargetWithNestedMapOfString();
bind(target, "nested_foo: bar\n" + "nested_value_foo: 123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
assertThat(target.getNested().get("value_foo")).isEqualTo("123");
}
@Test
public void testBindNestedMapOfStringWithUnderscoreAndUpperCase() throws Exception {
TargetWithNestedMapOfString target = new TargetWithNestedMapOfString();
bind(target, "NESTED_FOO: bar\n" + "NESTED_VALUE_FOO: 123");
assertThat(target.getNested().get("FOO")).isEqualTo("bar");
assertThat(target.getNested().get("VALUE_FOO")).isEqualTo("123");
}
@Test
public void testBindNestedMapOfStringReferenced() throws Exception {
TargetWithNestedMapOfString target = new TargetWithNestedMapOfString();
bind(target, "nested.foo: bar\n" + "nested[value.foo]: 123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
assertThat(target.getNested().get("value.foo")).isEqualTo("123");
}
@Test
public void testBindNestedProperties() throws Exception {
TargetWithNestedProperties target = new TargetWithNestedProperties();
bind(target, "nested.foo: bar\n" + "nested.value.foo: 123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
assertThat(target.getNested().get("value.foo")).isEqualTo("123");
}
@Test
public void testBindNestedMapOfEnum() throws Exception {
this.conversionService = new DefaultConversionService();
TargetWithNestedMapOfEnum target = new TargetWithNestedMapOfEnum();
bind(target, "nested.this: bar\n" + "nested.ThAt: 123");
assertThat(target.getNested().get(Bingo.THIS)).isEqualTo("bar");
assertThat(target.getNested().get(Bingo.THAT)).isEqualTo("123");
}
@Test
public void testBindNestedMapOfEnumRelaxedNames() throws Exception {
this.conversionService = new DefaultConversionService();
TargetWithNestedMapOfEnum target = new TargetWithNestedMapOfEnum();
bind(target, "nested.the-other: bar\n" + "nested.that_other: 123");
assertThat(target.getNested().get(Bingo.THE_OTHER)).isEqualTo("bar");
assertThat(target.getNested().get(Bingo.THAT_OTHER)).isEqualTo("123");
}
@Test
public void testBindNestedMapBracketReferenced() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested[foo]: bar\n" + "nested[value]: 123");
assertThat(target.getNested().get("value")).isEqualTo("123");
}
@Test
public void testBindNestedMapBracketReferencedAndPeriods() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested[foo]: bar\n" + "nested[foo.value]: 123");
assertThat(target.getNested().get("foo.value")).isEqualTo("123");
}
@SuppressWarnings("unchecked")
@Test
public void testBindDoubleNestedMapWithDotInKeys() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested.foo: bar.key\n" + "nested[bar.key].spam: bucket\n"
+ "nested[bar.key].value: 123\nnested[bar.key].foo: crap");
assertThat(target.getNested()).hasSize(2);
Map<String, Object> nestedMap = (Map<String, Object>) target.getNested()
.get("bar.key");
assertThat(nestedMap).as("nested map should be registered with 'bar.key'")
.isNotNull();
assertThat(nestedMap).hasSize(3);
assertThat(nestedMap.get("value")).isEqualTo("123");
assertThat(target.getNested().get("foo")).isEqualTo("bar.key");
assertThat(target.getNested().containsValue(target.getNested())).isFalse();
}
@SuppressWarnings("unchecked")
@Test
public void testBindDoubleNestedMap() throws Exception {
TargetWithNestedMap target = new TargetWithNestedMap();
bind(target, "nested.foo: bar\n" + "nested.bar.spam: bucket\n"
+ "nested.bar.value: 123\nnested.bar.foo: crap");
assertThat(target.getNested()).hasSize(2);
assertThat(((Map<String, Object>) target.getNested().get("bar"))).hasSize(3);
assertThat(((Map<String, Object>) target.getNested().get("bar")).get("value"))
.isEqualTo("123");
assertThat(target.getNested().get("foo")).isEqualTo("bar");
assertThat(target.getNested().containsValue(target.getNested())).isFalse();
}
@Test
public void testBindNestedMapOfListOfString() throws Exception {
TargetWithNestedMapOfListOfString target = new TargetWithNestedMapOfListOfString();
bind(target, "nested.foo[0]: bar\n" + "nested.bar[0]: bucket\n"
+ "nested.bar[1]: 123\nnested.bar[2]: crap");
assertThat(target.getNested()).hasSize(2);
assertThat(target.getNested().get("bar")).hasSize(3);
assertThat(target.getNested().get("bar").get(1)).isEqualTo("123");
assertThat(target.getNested().get("foo").toString()).isEqualTo("[bar]");
}
@Test
public void testBindNestedMapOfBean() throws Exception {
TargetWithNestedMapOfBean target = new TargetWithNestedMapOfBean();
bind(target, "nested.foo.foo: bar\n" + "nested.bar.foo: bucket");
assertThat(target.getNested()).hasSize(2);
assertThat(target.getNested().get("bar").getFoo()).isEqualTo("bucket");
}
@Test
public void testBindNestedMapOfListOfBean() throws Exception {
TargetWithNestedMapOfListOfBean target = new TargetWithNestedMapOfListOfBean();
bind(target, "nested.foo[0].foo: bar\n" + "nested.bar[0].foo: bucket\n"
+ "nested.bar[1].value: 123\nnested.bar[2].foo: crap");
assertThat(target.getNested()).hasSize(2);
assertThat(target.getNested().get("bar")).hasSize(3);
assertThat(target.getNested().get("bar").get(1).getValue()).isEqualTo(123);
assertThat(target.getNested().get("foo").get(0).getFoo()).isEqualTo("bar");
}
@Test
public void testBindErrorTypeMismatch() throws Exception {
VanillaTarget target = new VanillaTarget();
BindingResult result = bind(target, "foo: bar\n" + "value: foo");
assertThat(result.getErrorCount()).isEqualTo(1);
}
@Test
public void testBindErrorNotWritable() throws Exception {
this.expected.expectMessage("property 'spam'");
this.expected.expectMessage("not writable");
VanillaTarget target = new VanillaTarget();
BindingResult result = bind(target, "spam: bar\n" + "value: 123");
assertThat(result.getErrorCount()).isEqualTo(1);
}
@Test
public void testBindErrorNotWritableWithPrefix() throws Exception {
VanillaTarget target = new VanillaTarget();
BindingResult result = bind(target, "spam: bar\n" + "vanilla.value: 123",
"vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getValue()).isEqualTo(123);
}
@Test
public void testOnlyTopLevelFields() throws Exception {
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, null);
binder.setIgnoreUnknownFields(false);
binder.setIgnoreNestedProperties(true);
BindingResult result = bind(binder, target,
"foo: bar\n" + "value: 123\n" + "nested.bar: spam");
assertThat(target.getValue()).isEqualTo(123);
assertThat(target.getFoo()).isEqualTo("bar");
assertThat(result.getErrorCount()).isEqualTo(0);
}
@Test
public void testNoNestedFields() throws Exception {
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, "foo");
binder.setIgnoreUnknownFields(false);
binder.setIgnoreNestedProperties(true);
BindingResult result = bind(binder, target,
"foo.foo: bar\n" + "foo.value: 123\n" + "foo.nested.bar: spam");
assertThat(target.getValue()).isEqualTo(123);
assertThat(target.getFoo()).isEqualTo("bar");
assertThat(result.getErrorCount()).isEqualTo(0);
}
@Test
public void testBindMap() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target, "spam: bar\n" + "vanilla.value: 123",
"vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.get("value")).isEqualTo("123");
}
@Test
public void testBindMapWithClashInProperties() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target,
"vanilla.spam: bar\n" + "vanilla.spam.value: 123", "vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target).hasSize(2);
assertThat(target.get("spam")).isEqualTo("bar");
assertThat(target.get("spam.value")).isEqualTo("123");
}
@Test
public void testBindMapWithDeepClashInProperties() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target,
"vanilla.spam.foo: bar\n" + "vanilla.spam.foo.value: 123", "vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) target.get("spam");
assertThat(map.get("foo.value")).isEqualTo("123");
}
@Test
public void testBindMapWithDifferentDeepClashInProperties() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target,
"vanilla.spam.bar: bar\n" + "vanilla.spam.bar.value: 123", "vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) target.get("spam");
assertThat(map.get("bar.value")).isEqualTo("123");
}
@Test
public void testBindShallowMap() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target, "vanilla.spam: bar\n" + "vanilla.value: 123",
"vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.get("value")).isEqualTo("123");
}
@Test
public void testBindMapNestedMap() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target, "spam: bar\n" + "vanilla.foo.value: 123",
"vanilla");
assertThat(result.getErrorCount()).isEqualTo(0);
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) target.get("foo");
assertThat(map.get("value")).isEqualTo("123");
}
@SuppressWarnings("unchecked")
@Test
public void testBindOverlappingNestedMaps() throws Exception {
Map<String, Object> target = new LinkedHashMap<String, Object>();
BindingResult result = bind(target, "a.b.c.d: abc\na.b.c1.d1: efg");
assertThat(result.getErrorCount()).isEqualTo(0);
Map<String, Object> a = (Map<String, Object>) target.get("a");
Map<String, Object> b = (Map<String, Object>) a.get("b");
Map<String, Object> c = (Map<String, Object>) b.get("c");
assertThat(c.get("d")).isEqualTo("abc");
Map<String, Object> c1 = (Map<String, Object>) b.get("c1");
assertThat(c1.get("d1")).isEqualTo("efg");
}
@Test
public void testBindCaseInsensitiveEnumsWithoutConverter() throws Exception {
VanillaTarget target = new VanillaTarget();
doTestBindCaseInsensitiveEnums(target);
}
@Test
public void testBindCaseInsensitiveEnumsWithConverter() throws Exception {
VanillaTarget target = new VanillaTarget();
this.conversionService = new DefaultConversionService();
doTestBindCaseInsensitiveEnums(target);
}
@Test
public void testBindWithoutAlias() throws Exception {
VanillaTarget target = new VanillaTarget();
MutablePropertyValues properties = new MutablePropertyValues();
properties.add("flub", "a");
properties.add("foo", "b");
new RelaxedDataBinder(target).bind(properties);
assertThat(target.getFooBaz()).isNull();
assertThat(target.getFoo()).isEqualTo("b");
}
@Test
public void testBindWithAlias() throws Exception {
VanillaTarget target = new VanillaTarget();
MutablePropertyValues properties = new MutablePropertyValues();
properties.add("flub", "a");
properties.add("foo", "b");
new RelaxedDataBinder(target).withAlias("flub", "fooBaz").bind(properties);
assertThat(target.getFooBaz()).isEqualTo("a");
assertThat(target.getFoo()).isEqualTo("b");
}
@Test
public void testMixed() throws Exception {
// gh-3385
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, "test");
MutablePropertyValues values = new MutablePropertyValues();
values.add("test.FOO_BAZ", "boo");
values.add("test.foo-baz", "bar");
binder.bind(values);
assertThat(target.getFooBaz()).isEqualTo("boo");
}
@Test
public void testIndexBounds() throws Exception {
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, "test");
MutablePropertyValues values = new MutablePropertyValues();
values.add("test.objects[0]", "teststring");
binder.bind(values);
assertThat(target.getObjects()).containsExactly("teststring");
}
@Test
public void testMixedWithUpperCaseWord() throws Exception {
// gh-6803
VanillaTarget target = new VanillaTarget();
RelaxedDataBinder binder = getBinder(target, "test");
MutablePropertyValues values = new MutablePropertyValues();
values.add("test.mixed-u-p-p-e-r", "foo");
binder.bind(values);
assertThat(target.getMixedUPPER()).isEqualTo("foo");
}
private void doTestBindCaseInsensitiveEnums(VanillaTarget target) throws Exception {
BindingResult result = bind(target, "bingo: THIS");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.THIS);
result = bind(target, "bingo: oR");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.or);
result = bind(target, "bingo: that");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.THAT);
result = bind(target, "bingo: the-other");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.THE_OTHER);
result = bind(target, "bingo: the_other");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.THE_OTHER);
result = bind(target, "bingo: The_Other");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingo()).isEqualTo(Bingo.THE_OTHER);
result = bind(target, "bingos: The_Other");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingos()).contains(Bingo.THE_OTHER);
result = bind(target, "bingos: The_Other, that");
assertThat(result.getErrorCount()).isEqualTo(0);
assertThat(target.getBingos()).contains(Bingo.THE_OTHER, Bingo.THAT);
}
private BindingResult bind(Object target, String values) throws Exception {
return bind(target, values, null);
}
private BindingResult bind(Object target, String values, String namePrefix)
throws Exception {
return bind(getBinder(target, namePrefix), target, values);
}
private RelaxedDataBinder getBinder(Object target, String namePrefix) {
RelaxedDataBinder binder = new RelaxedDataBinder(target, namePrefix);
binder.setIgnoreUnknownFields(false);
LocalValidatorFactoryBean validatorFactoryBean = new LocalValidatorFactoryBean();
validatorFactoryBean.afterPropertiesSet();
binder.setValidator(validatorFactoryBean);
binder.setConversionService(this.conversionService);
return binder;
}
private BindingResult bind(DataBinder binder, Object target, String values)
throws Exception {
Properties properties = PropertiesLoaderUtils
.loadProperties(new ByteArrayResource(values.getBytes()));
binder.bind(new MutablePropertyValues(properties));
binder.validate();
return binder.getBindingResult();
}
@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = RequiredKeysValidator.class)
public @interface RequiredKeys {
String[] value();
String message() default "Required fields are not provided for field ''{0}''";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
public static class RequiredKeysValidator
implements ConstraintValidator<RequiredKeys, Map<String, Object>> {
private String[] fields;
@Override
public void initialize(RequiredKeys constraintAnnotation) {
this.fields = constraintAnnotation.value();
}
@Override
public boolean isValid(Map<String, Object> value,
ConstraintValidatorContext context) {
boolean valid = true;
for (String field : this.fields) {
if (!value.containsKey(field)) {
context.buildConstraintViolationWithTemplate(
"Missing field ''" + field + "''").addConstraintViolation();
valid = false;
}
}
return valid;
}
}
public static class TargetWithValidatedMap {
@RequiredKeys({"foo", "value"})
private Map<String, Object> info;
public Map<String, Object> getInfo() {
return this.info;
}
public void setInfo(Map<String, Object> nested) {
this.info = nested;
}
}
public static class TargetWithNestedMap {
private Map<String, Object> nested;
public Map<String, Object> getNested() {
return this.nested;
}
public void setNested(Map<String, Object> nested) {
this.nested = nested;
}
}
@SuppressWarnings("rawtypes")
public static class TargetWithNestedUntypedMap {
private Map nested;
public Map getNested() {
return this.nested;
}
public void setNested(Map nested) {
this.nested = nested;
}
}
public static class TargetWithNestedProperties {
private Properties nested;
public Properties getNested() {
return this.nested;
}
public void setNested(Properties nested) {
this.nested = nested;
}
}
public static class TargetWithNestedMapOfString {
private Map<String, String> nested;
public Map<String, String> getNested() {
return this.nested;
}
public void setNested(Map<String, String> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedMapOfEnum {
private Map<Bingo, Object> nested;
public Map<Bingo, Object> getNested() {
return this.nested;
}
public void setNested(Map<Bingo, Object> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedMapOfListOfString {
private Map<String, List<String>> nested;
public Map<String, List<String>> getNested() {
return this.nested;
}
public void setNested(Map<String, List<String>> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedMapOfListOfBean {
private Map<String, List<VanillaTarget>> nested;
public Map<String, List<VanillaTarget>> getNested() {
return this.nested;
}
public void setNested(Map<String, List<VanillaTarget>> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedMapOfBean {
private Map<String, VanillaTarget> nested;
public Map<String, VanillaTarget> getNested() {
return this.nested;
}
public void setNested(Map<String, VanillaTarget> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedList {
private List<String> nested;
public List<String> getNested() {
return this.nested;
}
public void setNested(List<String> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedListOfBean {
private List<VanillaTarget> nested;
public List<VanillaTarget> getNested() {
return this.nested;
}
public void setNested(List<VanillaTarget> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedListOfBeanWithList {
private List<TargetWithNestedListOfBean> nested;
public List<TargetWithNestedListOfBean> getNested() {
return this.nested;
}
public void setNested(List<TargetWithNestedListOfBean> nested) {
this.nested = nested;
}
}
public static class TargetWithReadOnlyNestedList {
private final List<String> nested = new ArrayList<String>();
public List<String> getNested() {
return this.nested;
}
}
public static class TargetWithReadOnlyDoubleNestedList {
TargetWithReadOnlyNestedList bean = new TargetWithReadOnlyNestedList();
public TargetWithReadOnlyNestedList getBean() {
return this.bean;
}
}
public static class TargetWithReadOnlyNestedCollection {
private final Collection<String> nested = new ArrayList<String>();
public Collection<String> getNested() {
return this.nested;
}
}
public static class TargetWithNestedSet {
private Set<String> nested = new LinkedHashSet<String>();
public Set<String> getNested() {
return this.nested;
}
public void setNested(Set<String> nested) {
this.nested = nested;
}
}
public static class TargetWithNestedObject {
private VanillaTarget nested;
private VanillaTarget anotherNested;
public VanillaTarget getNested() {
return this.nested;
}
public void setNested(VanillaTarget nested) {
this.nested = nested;
}
public VanillaTarget getAnotherNested() {
return this.anotherNested;
}
public void setAnotherNested(VanillaTarget anotherNested) {
this.anotherNested = anotherNested;
}
}
public static class VanillaTarget {
private String foo;
private char[] bar;
private int value;
private String foo_bar;
private String fooBaz;
private Bingo bingo;
private List<Bingo> bingos;
private List<Object> objects;
private String mixedUPPER;
public char[] getBar() {
return this.bar;
}
public void setBar(char[] bar) {
this.bar = bar;
}
public int getValue() {
return this.value;
}
public void setValue(int value) {
this.value = value;
}
public String getFoo() {
return this.foo;
}
public void setFoo(String foo) {
this.foo = foo;
}
public String getFoo_bar() {
return this.foo_bar;
}
public void setFoo_bar(String foo_bar) {
this.foo_bar = foo_bar;
}
public String getFooBaz() {
return this.fooBaz;
}
public void setFooBaz(String fooBaz) {
this.fooBaz = fooBaz;
}
public Bingo getBingo() {
return this.bingo;
}
public void setBingo(Bingo bingo) {
this.bingo = bingo;
}
public List<Bingo> getBingos() {
return this.bingos;
}
public void setBingos(List<Bingo> bingos) {
this.bingos = bingos;
}
public List<Object> getObjects() {
return this.objects;
}
public void setObjects(List<Object> objects) {
this.objects = objects;
}
public String getMixedUPPER() {
return this.mixedUPPER;
}
public void setMixedUPPER(String mixedUPPER) {
this.mixedUPPER = mixedUPPER;
}
}
enum Bingo {
THIS, or, THAT, THE_OTHER, THAT_OTHER
}
public static class ValidatedTarget {
@NotNull
private String foo;
public String getFoo() {
return this.foo;
}
public void setFoo(String foo) {
this.foo = foo;
}
}
}
| [
"[email protected]"
] | |
d0abcd1178008018c5c803bcd8020cafea74b037 | 0cb290b1c39a22c2a5a8db196de5a9d7154db6a7 | /practice2/src/test/java/hello/core/scope/SingletonWithPrototypeTest1.java | a30558d9071a843ba53953fe25c22306193c6c72 | [] | no_license | cocomongg/Spring_study | 38c8635e9eadc8dfb84e5a854712cb40098a4b88 | 7a768c36120d43976d36a774fc5f663148f688e4 | refs/heads/main | 2023-03-15T01:56:13.243955 | 2021-03-16T13:01:20 | 2021-03-16T13:01:20 | 328,735,428 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,341 | java | package hello.core.scope;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Scope;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class SingletonWithPrototypeTest1 {
@Test
void prototypeFind(){
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PrototypeBean.class);
PrototypeBean prototypeBean1 = ac.getBean(PrototypeBean.class);
prototypeBean1.addCount();
Assertions.assertThat(prototypeBean1.getCount()).isEqualTo(1);
PrototypeBean prototypeBean2 = ac.getBean(PrototypeBean.class);
prototypeBean2.addCount();
Assertions.assertThat(prototypeBean2.getCount()).isEqualTo(1);
}
@Scope("prototype")
static class PrototypeBean{
private int count = 0;
public void addCount(){
count++;
}
public int getCount(){
return count;
}
@PostConstruct
public void init(){
System.out.println("PrototypeBean.init " + this);
}
@PreDestroy
public void destroy(){
System.out.println("PrototypeBean.destroy");
}
}
}
| [
"[email protected]"
] | |
0774517103b7f188333fa4f8116da666bdf420fd | cab437fd1c7622361c08c4f6bd07811765fe3652 | /src/application/view/WatchStage.java | 21d350ad7161834dcda0ff230553fd56fa963f86 | [] | no_license | DovahZul/TripScheduler | 6b8df1e145403e4b416405c9608c5443d5becaa6 | a378597f8df634ef7189b7e97636f7c1f0716fdc | refs/heads/master | 2021-01-01T17:29:09.337426 | 2017-07-23T14:21:02 | 2017-07-23T14:21:02 | 98,081,788 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,792 | java | package application.view;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
public class WatchStage {
public StringProperty watchDate = new SimpleStringProperty();
public StringProperty watchTime = new SimpleStringProperty();
public StringProperty fio = new SimpleStringProperty();
public BooleanProperty checked = new SimpleBooleanProperty();
public BooleanProperty highlightProperty = new SimpleBooleanProperty();
public WatchStage() {
this("none", "none","none",false);
}
public void setHighlight( boolean value ) {
highlightProperty.set( value );
}
public boolean isHighlight() {
return highlightProperty.get();
}
public void setChecked(Boolean b) {
getChecked().set(b);
}
public BooleanProperty getChecked() {
return checked;
}
public void setWatchDate(String watchDate) {
this.watchDate.set(watchDate);
}
public StringProperty getWatchDate() {
return watchDate;
}
public void setWatchTime(String watchDate) {
this.watchTime.set(watchDate);
}
public StringProperty getWatchTime() {
return watchTime;
}
public void setFio(String watchDate) {
this.fio.set(watchDate);
}
public StringProperty getFio() {
return fio;
}
public WatchStage(String date, String time, String fio,Boolean b) {
this.watchDate = new SimpleStringProperty(date);
this.watchTime = new SimpleStringProperty(time);;
this.fio = new SimpleStringProperty(fio);
this.checked = new SimpleBooleanProperty(b);
}
}
| [
"[email protected]"
] | |
f6f0a78639820bdff4a218993c51dbf71a890200 | 817e947bb7c6dab2a48949d912397ff773859acc | /lib/src/main/java/com/tompee/nicehash/api/model/detailedproviderstat/DetailedProviderStat.java | 7d8d6b29da9567590af7fce48c1f22817157dfda | [
"MIT"
] | permissive | tompee26/nicehash-java-api | 9e8ea9e5ae28ef3c82f80379ed6d666c81d78069 | c10da4082f9e9b9a4fca7a14b8884c2cdc911141 | refs/heads/master | 2020-03-16T20:41:09.094938 | 2018-06-13T05:19:11 | 2018-06-13T05:19:11 | 132,968,434 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,496 | java | package com.tompee.nicehash.api.model.detailedproviderstat;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.tompee.nicehash.api.model.ResultBase;
import java.util.List;
/**
* Detailed provider statistics model
*/
@JsonIgnoreProperties(ignoreUnknown = true)
public class DetailedProviderStat extends ResultBase {
@JsonProperty("current")
private List<Current> current = null;
@JsonProperty("nh_wallet")
private Boolean nhWallet;
@JsonProperty("past")
private List<Past> past = null;
@JsonProperty("payments")
private List<Object> payments = null;
@JsonProperty("addr")
private String addr;
@JsonProperty("current")
public List<Current> getCurrent() {
return current;
}
public void setCurrent(List<Current> current) {
this.current = current;
}
public Boolean getNhWallet() {
return nhWallet;
}
public void setNhWallet(Boolean nhWallet) {
this.nhWallet = nhWallet;
}
public List<Past> getPast() {
return past;
}
public void setPast(List<Past> past) {
this.past = past;
}
public List<Object> getPayments() {
return payments;
}
public void setPayments(List<Object> payments) {
this.payments = payments;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
}
| [
"[email protected]"
] | |
c6e1603cba60f2f3c14b4ed10d84941413d05327 | 0bae337beb3f928121eefb8531dfcc6ba2a212f6 | /channelpopularity/src/channelpopularity/state/ULTRAPOPULARSTATE.java | 69d65a2ea622d42f1861e4a18f327d1141b37ef5 | [] | no_license | rmschw/channel-popularity | 7487dfff0d9d02a65f066bcbf5936d73e8608b41 | 5f6b134bb4daeb7ebf6133b292e6083f9f92c0a9 | refs/heads/main | 2023-07-16T18:19:14.516577 | 2021-08-24T20:14:10 | 2021-08-24T20:14:10 | 398,587,320 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,391 | java | package channelpopularity.state;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import channelpopularity.customExceptions.videoExistException;
import channelpopularity.customExceptions.adRequestException;
import channelpopularity.customExceptions.decinDisikeException;
import channelpopularity.customExceptions.decinLikeException;
import channelpopularity.customExceptions.removeVideoException;
import channelpopularity.operation.Operation;
import channelpopularity.state.factory.SimpleStateFactory;
/**
* ULTRAPOPULARSTATE For a channel to be in this state, its popularity score
* should be in the range (100000, INT_MAX]
*
* @author Ramesh Chowdarapally
*
*/
public class ULTRAPOPULARSTATE extends AbstractState implements StateI {
SimpleStateFactory simplestateFactory;
Map map = new HashMap();
/**
* addVideo add the video to channel
*
* @param video name of the video
*/
@Override
public String addVideo(String video) throws videoExistException {
super.addVideo(video);
return StateName.ULTRA_POPULAR + "__" + Operation.VIDEO_ADDED + "::" + video;
}
/**
* removeVideo removes the video from channel
*
* @param video name of the video
*/
@Override
public String removeVideo(String video) throws removeVideoException {
super.removeVideo(video);
return StateName.ULTRA_POPULAR + "__" + Operation.VIDEO_REMOVED + "::" + video;
}
/**
* metricsVideo metrics of the video
*
* @param video name of the video
* @param views number of views
* @param likes number of likes
* @param dislikes number of dislikes
*/
@Override
public String metricsVideo(String video, int views, int likes, int dislikes) throws decinLikeException, decinDisikeException{
super.metricsVideo(video, views, likes, dislikes);
return StateName.ULTRA_POPULAR + "__" + Operation.POPULARITY_SCORE_UPDATE + "::" + super.iAvgPS;
}
/**
*
* adRequest advertisement request method to get approved or rejected status
*
* @param video name of the video
* @param adLength advertisement length
*
*/
public String adRequest(String video, int adLength) throws adRequestException{
String strAcceptence = "";
if (adLength > 1 && adLength <= 40) {
strAcceptence = "APPROVED";
} else {
strAcceptence = "REJECTED";
}
return StateName.ULTRA_POPULAR + "__" + Operation.AD_REQUEST + "::" + strAcceptence;
}
}
| [
"[email protected]"
] | |
687fcf705dec00712f3c74160543329d038b689d | eaca8eba8c7950cdd754247e94d853642a29598b | /hutool-core/src/main/java/cn/hutool/core/collection/TransSpliterator.java | 7a9b43522c284b053591f6130b774174dfc60cdc | [
"LicenseRef-scancode-mulanpsl-2.0-en",
"LicenseRef-scancode-unknown-license-reference",
"MulanPSL-2.0"
] | permissive | scemsjyd/hutool | f200fd04c22b1f9339017a74bf3654733fe18e29 | 5889435e0998a4159f4c219ac001a44d50070b8c | refs/heads/v5-master | 2023-08-14T19:23:07.930243 | 2023-07-29T06:01:49 | 2023-07-29T06:01:49 | 311,835,724 | 0 | 0 | MulanPSL-2.0 | 2023-09-13T17:05:38 | 2020-11-11T02:00:25 | Java | UTF-8 | Java | false | false | 1,473 | java | package cn.hutool.core.collection;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* 使用给定的转换函数，转换源{@link Spliterator}为新类型的{@link Spliterator}
*
* @param <F> 源元素类型
* @param <T> 目标元素类型
* @author looly
* @since 5.4.3
*/
public class TransSpliterator<F, T> implements Spliterator<T> {
private final Spliterator<F> fromSpliterator;
private final Function<? super F, ? extends T> function;
public TransSpliterator(Spliterator<F> fromSpliterator, Function<? super F, ? extends T> function) {
this.fromSpliterator = fromSpliterator;
this.function = function;
}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
return fromSpliterator.tryAdvance(
fromElement -> action.accept(function.apply(fromElement)));
}
@Override
public void forEachRemaining(Consumer<? super T> action) {
fromSpliterator.forEachRemaining(fromElement -> action.accept(function.apply(fromElement)));
}
@Override
public Spliterator<T> trySplit() {
Spliterator<F> fromSplit = fromSpliterator.trySplit();
return (fromSplit != null) ? new TransSpliterator<>(fromSplit, function) : null;
}
@Override
public long estimateSize() {
return fromSpliterator.estimateSize();
}
@Override
public int characteristics() {
return fromSpliterator.characteristics()
& ~(Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.SORTED);
}
}
| [
"[email protected]"
] | |
67b9d4c63a4183b0cc0a960538a26764e2114295 | acc2f7ae47266fa764982bd9b9b21f57ccca0ad4 | /bm/bm_operation/src/main/java/com/lvjing/bm/controller/BookController.java | 63ba03665a5cde91260397bcc3ba24aac8e0ba55 | [] | no_license | JankenLv/Practice | de9139a8c268e6acc0415c499640f271d173010b | 2508f6cb67b2cad6a5cfc60856cbae0f824e6424 | refs/heads/master | 2020-04-07T04:31:43.153329 | 2018-12-12T14:53:39 | 2018-12-12T14:53:39 | 158,060,582 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 10,433 | java | package com.lvjing.bm.controller;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.lvjing.bm.entity.Book;
import com.lvjing.bm.entity.Category;
import com.lvjing.bm.service.BookService;
import com.lvjing.bm.service.CategoryService;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@Controller("bookController")
@MultipartConfig
public class BookController {
@Autowired
private BookService bookService;
@Autowired
private CategoryService categoryService;
// /book/main.do
public void main(HttpServletRequest request, HttpServletResponse response) throws IOException {
response.sendRedirect("list.do");
}
// /book/list.do
public void list(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
getBooks(request,response);
}
// /book/subList.do
public void subList(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
getBooks(request,response);
}
// /book/toAdd.do
public void toAdd(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
List<Category> subList = categoryService.getAll();
request.setAttribute("SubList",subList);
request.getRequestDispatcher("/WEB-INF/views/biz/add_book.jsp").forward(request,response);
}
// /book/add.do
public void add(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
List<Book> bookList = parseRequest(request, new Book());
bookService.add(bookList);
response.sendRedirect("list.do");
}
// /book/toModify.do
public void toModify(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
Integer id = Integer.valueOf(request.getParameter("id"));
Book book = bookService.getById(id);
List<Category> subList = categoryService.getAll();
request.setAttribute("SubList",subList);
request.setAttribute("Book",book);
request.getRequestDispatcher("/WEB-INF/views/biz/edit_book.jsp").forward(request,response);
}
// /book/modify.do
public void modify(HttpServletRequest request, HttpServletResponse response) throws IOException {
String id = request.getParameter("id");
if (!StringUtils.isEmpty(id)) {
Book book = bookService.getById(Integer.valueOf(id));
List<Book> bookList = parseRequest(request,book);
bookService.modify(bookList.get(0));
response.sendRedirect("list.do");
}
}
// /book/remove.do
public void remove(HttpServletRequest request, HttpServletResponse response) throws IOException {
Integer id = Integer.valueOf(request.getParameter("id"));
Book book = bookService.getById(id);
String path = book.getImgPath();
if (!StringUtils.isEmpty(path)) {
delPicture(path,request);
}
bookService.remove(id);
response.sendRedirect("list.do");
}
/**
* 解析request，获取表单项和上传的文件
* @param request request请求
* @param book Book对象
* @return 保存Book对象的集合
*/
private List<Book> parseRequest(HttpServletRequest request,Book book) {
int i = 1;
List<Book> bookList = new ArrayList<>();
DiskFileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload fileUpload = new ServletFileUpload(factory);
try {
List<FileItem> fileItems = fileUpload.parseRequest(request);
for (FileItem fileItem : fileItems) {
if (fileItem.isFormField()) {
switch (fileItem.getFieldName()) {
case "name":
String name = fileItem.getString("UTF-8");
if (!StringUtils.isEmpty(name)) {
book.setName(name);
}
break;
case "categoryId":
String categoryId = fileItem.getString("UTF-8");
if (!StringUtils.isEmpty(categoryId)) {
book.setCategoryId(Integer.valueOf(categoryId));
}
break;
case "level":
String level = fileItem.getString("UTF-8");
if (!StringUtils.isEmpty(level)) {
book.setLevel(Integer.valueOf(level));
}
break;
case "price":
String price = fileItem.getString("UTF-8");
if (!StringUtils.isEmpty(price)) {
book.setPrice(Integer.valueOf(price));
}
break;
}
} else {
try {
String name = fileItem.getName();
if (!StringUtils.isEmpty(name)) {
// 更新图片前先把旧的图片删除
String path = book.getImgPath();
if (!StringUtils.isEmpty(path)) {
delPicture(path,request);
}
// 更新图片
String suffix = name.substring(name.lastIndexOf("."));
String prefix = UUID.randomUUID().toString().replace("-","");
String fileName = prefix + suffix;
String realPath = request.getServletContext().getRealPath("/upload");
File file = new File(realPath);
if (!file.exists()) {
file.mkdirs();
}
String imgPath = realPath + File.separator + fileName;
InputStream is = fileItem.getInputStream();
FileOutputStream os = new FileOutputStream(imgPath);
byte[] b = new byte[1024];
int len = -1;
while ((len=is.read(b)) != -1) {
os.write(b);
}
os.flush();
is.close();
os.close();
book.setImgPath(imgPath);
System.out.println("图片保存路径：" + imgPath);
}
} catch (IOException e) {
e.printStackTrace();
}
}
// i==5代表已经解析完了一个Book对象的数据
if (i == 5) {
bookList.add(book);
book = new Book();
i = 0;
}
i++;
}
} catch (FileUploadException | UnsupportedEncodingException e) {
e.printStackTrace();
}
return bookList;
}
/**
* 查询图书（查询所有或根据分类ID查询），并把查询结果传递到前端页面
* @param request HttpServletRequest
* @param response HttpServletResponse
*/
private void getBooks(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 获取及设置分类ID
Integer catId = -1;
if (!StringUtils.isEmpty(request.getParameter("catId"))) {
catId = Integer.valueOf(request.getParameter("catId"));
}
// 获取及设置页码
int currentPage = 1;
String page = request.getParameter("page");
if (!StringUtils.isEmpty(page)) {
currentPage = Integer.parseInt(page);
}
// 使用PageHelper分页
String pageSize = request.getServletContext().getInitParameter("pageSize");
Integer size = StringUtils.isEmpty(pageSize) ? 8 : Integer.valueOf(pageSize);
Integer finalCatId = catId;
PageInfo<Book> pageInfo;
if (catId == -1) {
// 查询所有图书
pageInfo = PageHelper.startPage(currentPage, size).doSelectPageInfo(() -> bookService.getAll());
} else {
// 查询某一分类下的图书
pageInfo = PageHelper.startPage(currentPage, size).doSelectPageInfo(() -> bookService.getByCatId(finalCatId));
}
List<Category> subList = categoryService.getAll();
request.setAttribute("PageInfo",pageInfo);
request.setAttribute("CatId",catId);
request.setAttribute("SubList",subList);
request.getRequestDispatcher("/WEB-INF/views/biz/book_list.jsp").forward(request,response);
}
/**
* 删除保存在磁盘的图片
* @param imgPath 图片路径
*/
private void delPicture(String imgPath,HttpServletRequest request) {
String realPath = request.getServletContext().getRealPath("/upload");
String separator = imgPath.contains("/") ? "/" : "\\";
String imgName = imgPath.substring(imgPath.lastIndexOf(separator)+1);
String img = realPath + File.separator + imgName;
File file = new File(img);
if (file.getParentFile().exists()) {
System.out.println(file.delete() ? "<<<========图片删除成功========>>>" : "<<<========图片不存在========>>>");
}
}
}
| [
"[email protected]"
] | |
92acab7866f54c550d598e1c456acbe5d0fdc2c1 | a7148cb4f365f29a5169f456ce23f35a744081af | /cidadaoDeBemEJB/ejbModule/cidadaoDeBem/ejb/facade/InfratorFacade.java | 580bce76bff9d5b564d115d0bcc93a5563b11107 | [] | no_license | janjanRamos/cidadaodebem | 167c4eec19b64f2223979134f54723af54ebb898 | e3c2e1ab9078df352ac363423d5d8ddfb3975d7d | refs/heads/master | 2021-01-19T08:55:37.970132 | 2015-09-15T20:41:03 | 2015-09-15T20:41:03 | 42,475,439 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 480 | java | package cidadaoDeBem.ejb.facade;
import java.util.List;
import javax.ejb.Local;
import cidadaoDeBem.ejb.modelo.Infrator;
@Local
public interface InfratorFacade {
public List<Infrator> buscarInfrator(String nome, String cpf,
String apelido, String nomeGenitora);
public List<Infrator> buscarInfrator(String nome);
public Infrator save(Infrator infrator);
public Infrator update(Infrator infrator);
public Infrator buscarInfrator(int id);
}
| [
"[email protected]"
] | |
ec4445370b42e29c355f9d6caeb4e79bfbb3ec8b | 4627d514d6664526f58fbe3cac830a54679749cd | /results/randoop5/math-org.apache.commons.math.geometry.CardanEulerSingularityException-13/RegressionTest3.java | 2ecb3b6c8167b3ef98f9b5715ebaec272ce6f850 | [] | no_license | STAMP-project/Cling-application | c624175a4aa24bb9b29b53f9b84c42a0f18631bd | 0ff4d7652b434cbfd9be8d8bb38cfc8d8eaa51b5 | refs/heads/master | 2022-07-27T09:30:16.423362 | 2022-07-19T12:01:46 | 2022-07-19T12:01:46 | 254,310,667 | 2 | 2 | null | 2021-07-12T12:29:50 | 2020-04-09T08:11:35 | null | UTF-8 | Java | false | false | 2,296,952 | java | import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class RegressionTest3 {
public static boolean debug = false;
@Test
public void test1501() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1501");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str32 = cardanEulerSingularityException6.getPattern();
java.lang.String str33 = cardanEulerSingularityException6.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Cardan angles singularity" + "'", str32, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str33, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1502() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1502");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
java.lang.String str11 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
}
@Test
public void test1503() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1503");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
java.lang.String str11 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray12 = cardanEulerSingularityException1.getArguments();
java.lang.String str13 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
}
@Test
public void test1504() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1504");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
java.lang.String str18 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str27 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.String str32 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException35.getSuppressed();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException35.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
java.lang.Object[] objArray55 = cardanEulerSingularityException53.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray58 = cardanEulerSingularityException57.getArguments();
cardanEulerSingularityException53.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray60 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException62.getSuppressed();
java.lang.String str65 = cardanEulerSingularityException62.getPattern();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
java.lang.Object[] objArray67 = cardanEulerSingularityException57.getArguments();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException57.getSuppressed();
java.lang.Object[] objArray69 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException71.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException71.getSuppressed();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray78 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException80 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray81 = cardanEulerSingularityException80.getArguments();
java.lang.String str82 = cardanEulerSingularityException80.getPattern();
java.lang.Object[] objArray83 = cardanEulerSingularityException80.getArguments();
java.lang.Object[] objArray84 = cardanEulerSingularityException80.getArguments();
java.lang.String str85 = cardanEulerSingularityException80.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException87 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray88 = cardanEulerSingularityException87.getArguments();
java.lang.Throwable[] throwableArray89 = cardanEulerSingularityException87.getSuppressed();
java.lang.Throwable[] throwableArray90 = cardanEulerSingularityException87.getSuppressed();
cardanEulerSingularityException80.addSuppressed((java.lang.Throwable) cardanEulerSingularityException87);
java.lang.Object[] objArray92 = cardanEulerSingularityException80.getArguments();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.Object[] objArray94 = cardanEulerSingularityException80.getArguments();
java.lang.String str95 = cardanEulerSingularityException80.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.String str97 = cardanEulerSingularityException80.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertNotNull(objArray81);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray81), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray81), "[]");
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Euler angles singularity" + "'", str82, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Euler angles singularity" + "'", str85, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray88);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray88), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray88), "[]");
org.junit.Assert.assertNotNull(throwableArray89);
org.junit.Assert.assertNotNull(throwableArray90);
org.junit.Assert.assertNotNull(objArray92);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray92), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray92), "[]");
org.junit.Assert.assertNotNull(objArray94);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray94), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray94), "[]");
org.junit.Assert.assertEquals("'" + str95 + "' != '" + "Euler angles singularity" + "'", str95, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str97 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str97, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1505() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1505");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str18 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
java.lang.String str20 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray22 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException5.getArguments();
java.lang.String str24 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray40 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException30.getSuppressed();
java.lang.Object[] objArray42 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException44.getSuppressed();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException55.getSuppressed();
java.lang.Object[] objArray59 = cardanEulerSingularityException55.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray62 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray64 = cardanEulerSingularityException61.getArguments();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException69 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray70 = cardanEulerSingularityException69.getArguments();
java.lang.Object[] objArray71 = cardanEulerSingularityException69.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
cardanEulerSingularityException69.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Object[] objArray76 = cardanEulerSingularityException73.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException78 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray79 = cardanEulerSingularityException78.getArguments();
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException78.getSuppressed();
java.lang.String str81 = cardanEulerSingularityException78.getPattern();
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
java.lang.Object[] objArray83 = cardanEulerSingularityException73.getArguments();
java.lang.Object[] objArray84 = cardanEulerSingularityException73.getArguments();
java.lang.Throwable[] throwableArray85 = cardanEulerSingularityException73.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException87 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray88 = cardanEulerSingularityException87.getArguments();
java.lang.Throwable[] throwableArray89 = cardanEulerSingularityException87.getSuppressed();
java.lang.String str90 = cardanEulerSingularityException87.getPattern();
java.lang.Throwable[] throwableArray91 = cardanEulerSingularityException87.getSuppressed();
java.lang.Throwable[] throwableArray92 = cardanEulerSingularityException87.getSuppressed();
java.lang.Object[] objArray93 = cardanEulerSingularityException87.getArguments();
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException87);
java.lang.Throwable[] throwableArray95 = cardanEulerSingularityException73.getSuppressed();
cardanEulerSingularityException61.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.String str97 = cardanEulerSingularityException61.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertNotNull(throwableArray85);
org.junit.Assert.assertNotNull(objArray88);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray88), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray88), "[]");
org.junit.Assert.assertNotNull(throwableArray89);
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Euler angles singularity" + "'", str90, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray91);
org.junit.Assert.assertNotNull(throwableArray92);
org.junit.Assert.assertNotNull(objArray93);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray93), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray93), "[]");
org.junit.Assert.assertNotNull(throwableArray95);
org.junit.Assert.assertEquals("'" + str97 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str97, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1506() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1506");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str12 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException6.getArguments();
java.lang.String str14 = cardanEulerSingularityException6.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Cardan angles singularity" + "'", str12, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str14, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1507() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1507");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException12.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException12.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException12.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.String str20 = cardanEulerSingularityException12.toString();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str20, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1508() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1508");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray6 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray31 = cardanEulerSingularityException8.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray33 = cardanEulerSingularityException8.getArguments();
java.lang.String str34 = cardanEulerSingularityException8.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str34, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1509() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1509");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException24.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray41 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str43 = cardanEulerSingularityException5.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str43, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1510() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1510");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException10.getSuppressed();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException10.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray15);
}
@Test
public void test1511() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1511");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException5.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str22 = cardanEulerSingularityException5.getPattern();
java.lang.String str23 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException5.getArguments();
java.lang.String str25 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException5.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
}
@Test
public void test1512() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1512");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException6.getSuppressed();
java.lang.Object[] objArray13 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str16 = cardanEulerSingularityException15.getPattern();
java.lang.Object[] objArray17 = cardanEulerSingularityException15.getArguments();
java.lang.String str18 = cardanEulerSingularityException15.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str21 = cardanEulerSingularityException20.getPattern();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Object[] objArray46 = cardanEulerSingularityException43.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException48.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException48.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Object[] objArray53 = cardanEulerSingularityException48.getArguments();
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Object[] objArray55 = cardanEulerSingularityException15.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException6.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertNotNull(throwableArray58);
}
@Test
public void test1513() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1513");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray11 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
}
@Test
public void test1514() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1514");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException6.getSuppressed();
java.lang.Object[] objArray13 = cardanEulerSingularityException6.getArguments();
java.lang.String str14 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str16 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray17 = cardanEulerSingularityException6.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Cardan angles singularity" + "'", str14, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Cardan angles singularity" + "'", str16, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
}
@Test
public void test1515() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1515");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray4 = cardanEulerSingularityException3.getArguments();
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException8.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray25 = cardanEulerSingularityException3.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass28 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(wildcardClass28);
}
@Test
public void test1516() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1516");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray16 = cardanEulerSingularityException15.getArguments();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.String str18 = cardanEulerSingularityException15.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray33 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str37 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray38 = cardanEulerSingularityException20.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str40 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
}
@Test
public void test1517() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1517");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException5.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException19.getSuppressed();
java.lang.String str22 = cardanEulerSingularityException19.getPattern();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException19.getSuppressed();
java.lang.Object[] objArray25 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str27 = cardanEulerSingularityException19.getPattern();
java.lang.String str28 = cardanEulerSingularityException19.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str28, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1518() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1518");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str25 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException5.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException28.getPattern();
java.lang.String str37 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
java.lang.Object[] objArray48 = cardanEulerSingularityException46.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException50.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException54.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Object[] objArray59 = cardanEulerSingularityException54.getArguments();
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException54.getSuppressed();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray65 = cardanEulerSingularityException63.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray68 = cardanEulerSingularityException67.getArguments();
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray72 = cardanEulerSingularityException71.getArguments();
java.lang.Object[] objArray73 = cardanEulerSingularityException71.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException75 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException75.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
cardanEulerSingularityException71.addSuppressed((java.lang.Throwable) cardanEulerSingularityException75);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException71.getSuppressed();
cardanEulerSingularityException67.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException83 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str84 = cardanEulerSingularityException83.getPattern();
java.lang.Throwable[] throwableArray85 = cardanEulerSingularityException83.getSuppressed();
cardanEulerSingularityException67.addSuppressed((java.lang.Throwable) cardanEulerSingularityException83);
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException83);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Object[] objArray89 = cardanEulerSingularityException41.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Throwable[] throwableArray91 = cardanEulerSingularityException41.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray85);
org.junit.Assert.assertNotNull(objArray89);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray89), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray89), "[]");
org.junit.Assert.assertNotNull(throwableArray91);
}
@Test
public void test1519() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1519");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException3.getPattern();
java.lang.String str10 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.Object[] objArray19 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException21.getSuppressed();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Object[] objArray26 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str29 = cardanEulerSingularityException28.getPattern();
java.lang.Object[] objArray30 = cardanEulerSingularityException28.getArguments();
java.lang.String str31 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray35 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
java.lang.String str41 = cardanEulerSingularityException39.getPattern();
java.lang.String str42 = cardanEulerSingularityException39.getPattern();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
}
@Test
public void test1520() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1520");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str10 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
java.lang.String str12 = cardanEulerSingularityException9.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str15 = cardanEulerSingularityException14.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str18 = cardanEulerSingularityException9.getPattern();
java.lang.String str19 = cardanEulerSingularityException9.getPattern();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str23 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Cardan angles singularity" + "'", str5, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Cardan angles singularity" + "'", str23, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
}
@Test
public void test1521() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1521");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray37 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException39.getSuppressed();
java.lang.String str42 = cardanEulerSingularityException39.getPattern();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
java.lang.Object[] objArray44 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException34.getSuppressed();
java.lang.Object[] objArray46 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str56 = cardanEulerSingularityException34.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
}
@Test
public void test1522() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1522");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException36.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
java.lang.Object[] objArray45 = cardanEulerSingularityException42.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.String str51 = cardanEulerSingularityException49.getPattern();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException49.getSuppressed();
java.lang.String str53 = cardanEulerSingularityException49.getPattern();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException49.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException49.getPattern();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.String str58 = cardanEulerSingularityException49.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
java.lang.String str62 = cardanEulerSingularityException60.getPattern();
java.lang.Object[] objArray63 = cardanEulerSingularityException60.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException65 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray66 = cardanEulerSingularityException65.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException65.getArguments();
java.lang.String str68 = cardanEulerSingularityException65.getPattern();
java.lang.String str69 = cardanEulerSingularityException65.getPattern();
cardanEulerSingularityException60.addSuppressed((java.lang.Throwable) cardanEulerSingularityException65);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
java.lang.Throwable[] throwableArray74 = cardanEulerSingularityException72.getSuppressed();
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException72.getSuppressed();
java.lang.Throwable[] throwableArray76 = cardanEulerSingularityException72.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException78 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray79 = cardanEulerSingularityException78.getArguments();
java.lang.Object[] objArray80 = cardanEulerSingularityException78.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException82 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException84 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException82.addSuppressed((java.lang.Throwable) cardanEulerSingularityException84);
cardanEulerSingularityException78.addSuppressed((java.lang.Throwable) cardanEulerSingularityException82);
cardanEulerSingularityException72.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
java.lang.Throwable[] throwableArray88 = cardanEulerSingularityException72.getSuppressed();
cardanEulerSingularityException65.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.String str90 = cardanEulerSingularityException72.getPattern();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Object[] objArray93 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray94 = cardanEulerSingularityException18.getSuppressed();
java.lang.Class<?> wildcardClass95 = throwableArray94.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Euler angles singularity" + "'", str62, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Cardan angles singularity" + "'", str68, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str69 + "' != '" + "Cardan angles singularity" + "'", str69, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(throwableArray74);
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(throwableArray76);
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(throwableArray88);
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Cardan angles singularity" + "'", str90, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray93);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray93), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray93), "[]");
org.junit.Assert.assertNotNull(throwableArray94);
org.junit.Assert.assertNotNull(wildcardClass95);
}
@Test
public void test1523() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1523");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray26 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
}
@Test
public void test1524() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1524");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray45 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray48 = cardanEulerSingularityException1.getArguments();
java.lang.Class<?> wildcardClass49 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(wildcardClass49);
}
@Test
public void test1525() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1525");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException17.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray28 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray30 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray31 = cardanEulerSingularityException17.getArguments();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException17.getSuppressed();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
}
@Test
public void test1526() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1526");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
}
@Test
public void test1527() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1527");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException8.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException8.getArguments();
java.lang.String str34 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException8.getSuppressed();
java.lang.Object[] objArray36 = cardanEulerSingularityException8.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
}
@Test
public void test1528() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1528");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
java.lang.String str26 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
}
@Test
public void test1529() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1529");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str18 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
java.lang.String str20 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray22 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException5.getArguments();
java.lang.String str24 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException5.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str26, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1530() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1530");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Class<?> wildcardClass27 = cardanEulerSingularityException20.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(wildcardClass27);
}
@Test
public void test1531() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1531");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException11.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str25 = cardanEulerSingularityException24.getPattern();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str30 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str32 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str42 = cardanEulerSingularityException34.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
java.lang.String str46 = cardanEulerSingularityException44.getPattern();
java.lang.Object[] objArray47 = cardanEulerSingularityException44.getArguments();
java.lang.Object[] objArray48 = cardanEulerSingularityException44.getArguments();
java.lang.String str49 = cardanEulerSingularityException44.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Object[] objArray56 = cardanEulerSingularityException21.getArguments();
java.lang.String str57 = cardanEulerSingularityException21.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Cardan angles singularity" + "'", str30, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str57, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1532() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1532");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str29 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray32 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str37 = cardanEulerSingularityException36.getPattern();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
java.lang.String str39 = cardanEulerSingularityException36.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str42 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str47 = cardanEulerSingularityException46.getPattern();
java.lang.Object[] objArray48 = cardanEulerSingularityException46.getArguments();
java.lang.String str49 = cardanEulerSingularityException46.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str52 = cardanEulerSingularityException51.getPattern();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Object[] objArray57 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
}
@Test
public void test1533() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1533");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Cardan angles singularity" + "'", str6, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
}
@Test
public void test1534() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1534");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray29 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray32 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException24.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Cardan angles singularity" + "'", str12, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
}
@Test
public void test1535() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1535");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Object[] objArray46 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException36.getSuppressed();
java.lang.String str50 = cardanEulerSingularityException36.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
}
@Test
public void test1536() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1536");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException23.getSuppressed();
java.lang.String str31 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException33.getArguments();
java.lang.String str38 = cardanEulerSingularityException33.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Object[] objArray43 = cardanEulerSingularityException40.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
java.lang.Object[] objArray48 = cardanEulerSingularityException46.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException50.getSuppressed();
java.lang.Object[] objArray54 = cardanEulerSingularityException50.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray59 = cardanEulerSingularityException56.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
java.lang.Object[] objArray61 = cardanEulerSingularityException56.getArguments();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException56.getSuppressed();
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException56.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException65 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException65.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
java.lang.Throwable[] throwableArray69 = cardanEulerSingularityException65.getSuppressed();
java.lang.Throwable[] throwableArray70 = cardanEulerSingularityException65.getSuppressed();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException65);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException73.getSuppressed();
java.lang.String str76 = cardanEulerSingularityException73.getPattern();
java.lang.Throwable[] throwableArray77 = cardanEulerSingularityException73.getSuppressed();
java.lang.String str78 = cardanEulerSingularityException73.getPattern();
java.lang.String str79 = cardanEulerSingularityException73.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertNotNull(throwableArray69);
org.junit.Assert.assertNotNull(throwableArray70);
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray77);
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str79 + "' != '" + "Euler angles singularity" + "'", str79, "Euler angles singularity");
}
@Test
public void test1537() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1537");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str22 = cardanEulerSingularityException20.getPattern();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException20.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.String str38 = cardanEulerSingularityException36.getPattern();
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
java.lang.String str45 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException48.getSuppressed();
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException48.getSuppressed();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException48.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
java.lang.Object[] objArray56 = cardanEulerSingularityException54.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
cardanEulerSingularityException54.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Class<?> wildcardClass68 = cardanEulerSingularityException41.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Cardan angles singularity" + "'", str44, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Cardan angles singularity" + "'", str45, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertNotNull(wildcardClass68);
}
@Test
public void test1538() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1538");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str29 = cardanEulerSingularityException26.getPattern();
java.lang.String str30 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException26.getSuppressed();
java.lang.Class<?> wildcardClass33 = throwableArray32.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Cardan angles singularity" + "'", str21, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(wildcardClass33);
}
@Test
public void test1539() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1539");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str31 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException28.getPattern();
java.lang.String str34 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray36 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException28.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
}
@Test
public void test1540() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1540");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException17.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray28 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray30 = cardanEulerSingularityException17.getArguments();
java.lang.String str31 = cardanEulerSingularityException17.getPattern();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
}
@Test
public void test1541() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1541");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray12 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException6.getSuppressed();
java.lang.Class<?> wildcardClass14 = throwableArray13.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertNotNull(wildcardClass14);
}
@Test
public void test1542() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1542");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray8 = cardanEulerSingularityException1.getArguments();
java.lang.String str9 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str9, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1543() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1543");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException1.getArguments();
java.lang.String str22 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str22, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1544() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1544");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
java.lang.Object[] objArray18 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException16.getSuppressed();
java.lang.String str24 = cardanEulerSingularityException16.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str26 = cardanEulerSingularityException16.getPattern();
java.lang.String str27 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException16.getSuppressed();
java.lang.Object[] objArray29 = cardanEulerSingularityException16.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
}
@Test
public void test1545() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1545");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.String str22 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
java.lang.String str29 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray31 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException24.getArguments();
java.lang.String str34 = cardanEulerSingularityException24.getPattern();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
}
@Test
public void test1546() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1546");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException3.getSuppressed();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
java.lang.String str25 = cardanEulerSingularityException21.getPattern();
java.lang.String str26 = cardanEulerSingularityException21.getPattern();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.String str28 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException3.getSuppressed();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray29);
}
@Test
public void test1547() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1547");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray13 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException1.getArguments();
java.lang.String str15 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
}
@Test
public void test1548() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1548");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
java.lang.Object[] objArray18 = cardanEulerSingularityException16.getArguments();
java.lang.String str19 = cardanEulerSingularityException16.getPattern();
java.lang.String str20 = cardanEulerSingularityException16.getPattern();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException23.getSuppressed();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException23.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
java.lang.Object[] objArray31 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str41 = cardanEulerSingularityException23.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str43 = cardanEulerSingularityException23.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Cardan angles singularity" + "'", str19, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Cardan angles singularity" + "'", str20, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Cardan angles singularity" + "'", str43, "Cardan angles singularity");
}
@Test
public void test1549() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1549");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray45 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str50 = cardanEulerSingularityException49.getPattern();
java.lang.String str51 = cardanEulerSingularityException49.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Object[] objArray53 = cardanEulerSingularityException49.getArguments();
java.lang.String str54 = cardanEulerSingularityException49.getPattern();
java.lang.String str55 = cardanEulerSingularityException49.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Cardan angles singularity" + "'", str50, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Cardan angles singularity" + "'", str51, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Cardan angles singularity" + "'", str54, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str55, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1550() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1550");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str10 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str19 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.String str24 = cardanEulerSingularityException22.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
java.lang.String str31 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException34.getSuppressed();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException34.getSuppressed();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException34.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException40.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException34.getSuppressed();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str55 = cardanEulerSingularityException34.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Cardan angles singularity" + "'", str19, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Cardan angles singularity" + "'", str30, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str55, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1551() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1551");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray18 = cardanEulerSingularityException5.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
}
@Test
public void test1552() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1552");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str4, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1553() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1553");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.String str22 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
java.lang.String str29 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
}
@Test
public void test1554() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1554");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.String str12 = cardanEulerSingularityException10.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray16 = cardanEulerSingularityException15.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException15.getArguments();
java.lang.String str18 = cardanEulerSingularityException15.getPattern();
java.lang.String str19 = cardanEulerSingularityException15.getPattern();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Object[] objArray21 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray23 = cardanEulerSingularityException10.getArguments();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Cardan angles singularity" + "'", str19, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
}
@Test
public void test1555() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1555");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str11 = cardanEulerSingularityException3.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str11, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1556() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1556");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException7.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException7.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str15 = cardanEulerSingularityException14.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
java.lang.String str17 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str20 = cardanEulerSingularityException19.getPattern();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str25 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.String str27 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str30 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException14.getSuppressed();
java.lang.Object[] objArray39 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str41 = cardanEulerSingularityException1.getPattern();
java.lang.String str42 = cardanEulerSingularityException1.getPattern();
java.lang.String str43 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str43, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1557() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1557");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException7.getSuppressed();
java.lang.Object[] objArray10 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str16 = cardanEulerSingularityException14.getPattern();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException14.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException14.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException14.getSuppressed();
java.lang.String str20 = cardanEulerSingularityException14.getPattern();
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str23 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.String str27 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray28 = cardanEulerSingularityException25.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
java.lang.String str34 = cardanEulerSingularityException30.getPattern();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException37.getSuppressed();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException37.getSuppressed();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException37.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
java.lang.Object[] objArray45 = cardanEulerSingularityException43.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException37.getSuppressed();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.String str55 = cardanEulerSingularityException37.getPattern();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.String str57 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray60 = cardanEulerSingularityException59.getArguments();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException59.getSuppressed();
java.lang.String str62 = cardanEulerSingularityException59.getPattern();
java.lang.Object[] objArray63 = cardanEulerSingularityException59.getArguments();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException59.getSuppressed();
java.lang.Object[] objArray65 = cardanEulerSingularityException59.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray70 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.String str75 = cardanEulerSingularityException68.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray78 = cardanEulerSingularityException77.getArguments();
java.lang.String str79 = cardanEulerSingularityException77.getPattern();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException77.getSuppressed();
java.lang.Object[] objArray82 = cardanEulerSingularityException77.getArguments();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException85 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray86 = cardanEulerSingularityException85.getArguments();
java.lang.String str87 = cardanEulerSingularityException85.getPattern();
java.lang.Object[] objArray88 = cardanEulerSingularityException85.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException90 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray91 = cardanEulerSingularityException90.getArguments();
java.lang.Object[] objArray92 = cardanEulerSingularityException90.getArguments();
cardanEulerSingularityException85.addSuppressed((java.lang.Throwable) cardanEulerSingularityException90);
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
java.lang.Object[] objArray95 = cardanEulerSingularityException59.getArguments();
java.lang.Throwable[] throwableArray96 = cardanEulerSingularityException59.getSuppressed();
java.lang.Object[] objArray97 = cardanEulerSingularityException59.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Cardan angles singularity" + "'", str33, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Cardan angles singularity" + "'", str62, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Euler angles singularity" + "'", str75, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertEquals("'" + str79 + "' != '" + "Euler angles singularity" + "'", str79, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray88);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray88), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray88), "[]");
org.junit.Assert.assertNotNull(objArray91);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray91), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray91), "[]");
org.junit.Assert.assertNotNull(objArray92);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray92), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray92), "[]");
org.junit.Assert.assertNotNull(objArray95);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray95), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray95), "[]");
org.junit.Assert.assertNotNull(throwableArray96);
org.junit.Assert.assertNotNull(objArray97);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray97), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray97), "[]");
}
@Test
public void test1558() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1558");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException5.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertNotNull(throwableArray9);
}
@Test
public void test1559() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1559");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str31 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass33 = throwableArray32.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(wildcardClass33);
}
@Test
public void test1560() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1560");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str25 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException5.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException28.getPattern();
java.lang.String str37 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str40 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
}
@Test
public void test1561() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1561");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.String str16 = cardanEulerSingularityException5.getPattern();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str20 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
java.lang.String str22 = cardanEulerSingularityException19.getPattern();
java.lang.String str23 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Object[] objArray26 = cardanEulerSingularityException19.getArguments();
java.lang.String str27 = cardanEulerSingularityException19.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str27, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1562() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1562");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray10 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException3.getPattern();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
}
@Test
public void test1563() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1563");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException30.getSuppressed();
java.lang.Object[] objArray34 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str44 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str47 = cardanEulerSingularityException46.getPattern();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException46.getSuppressed();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str52 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str54 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str56 = cardanEulerSingularityException19.getPattern();
java.lang.String str57 = cardanEulerSingularityException19.getPattern();
java.lang.Class<?> wildcardClass58 = cardanEulerSingularityException19.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Cardan angles singularity" + "'", str52, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Cardan angles singularity" + "'", str56, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Cardan angles singularity" + "'", str57, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass58);
}
@Test
public void test1564() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1564");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.String str22 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
java.lang.String str29 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray31 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Object[] objArray47 = cardanEulerSingularityException37.getArguments();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException37.getSuppressed();
java.lang.Object[] objArray49 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str57 = cardanEulerSingularityException37.getPattern();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
java.lang.Object[] objArray62 = cardanEulerSingularityException60.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
cardanEulerSingularityException60.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.Object[] objArray67 = cardanEulerSingularityException64.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException69 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray70 = cardanEulerSingularityException69.getArguments();
java.lang.Throwable[] throwableArray71 = cardanEulerSingularityException69.getSuppressed();
java.lang.String str72 = cardanEulerSingularityException69.getPattern();
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException69);
java.lang.Object[] objArray74 = cardanEulerSingularityException64.getArguments();
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException64.getSuppressed();
java.lang.Object[] objArray76 = cardanEulerSingularityException64.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException78 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException80 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException78.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.Throwable[] throwableArray82 = cardanEulerSingularityException78.getSuppressed();
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException85 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str86 = cardanEulerSingularityException85.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException88 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str89 = cardanEulerSingularityException88.getPattern();
java.lang.Throwable[] throwableArray90 = cardanEulerSingularityException88.getSuppressed();
cardanEulerSingularityException85.addSuppressed((java.lang.Throwable) cardanEulerSingularityException88);
cardanEulerSingularityException78.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
java.lang.String str94 = cardanEulerSingularityException37.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(throwableArray71);
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
org.junit.Assert.assertNotNull(throwableArray82);
org.junit.Assert.assertEquals("'" + str86 + "' != '" + "Euler angles singularity" + "'", str86, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str89 + "' != '" + "Euler angles singularity" + "'", str89, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray90);
org.junit.Assert.assertEquals("'" + str94 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str94, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1565() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1565");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
java.lang.String str27 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException29.getSuppressed();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException29.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str37 = cardanEulerSingularityException36.getPattern();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
java.lang.String str39 = cardanEulerSingularityException36.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str42 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str47 = cardanEulerSingularityException46.getPattern();
java.lang.Object[] objArray48 = cardanEulerSingularityException46.getArguments();
java.lang.String str49 = cardanEulerSingularityException46.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str52 = cardanEulerSingularityException51.getPattern();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException36.getSuppressed();
java.lang.Object[] objArray61 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.String str63 = cardanEulerSingularityException36.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.String str65 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Cardan angles singularity" + "'", str19, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str65, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1566() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1566");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException16.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException22.getSuppressed();
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str31 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray40 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException5.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
}
@Test
public void test1567() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1567");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException20.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
java.lang.Object[] objArray31 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException33.getSuppressed();
java.lang.Object[] objArray37 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException39.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
java.lang.Object[] objArray44 = cardanEulerSingularityException39.getArguments();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException39.getSuppressed();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException39.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Object[] objArray50 = cardanEulerSingularityException48.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray53 = cardanEulerSingularityException52.getArguments();
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException52.getSuppressed();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException39.getSuppressed();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
java.lang.Object[] objArray59 = cardanEulerSingularityException39.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
}
@Test
public void test1568() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1568");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str31 = cardanEulerSingularityException1.getPattern();
java.lang.Class<?> wildcardClass32 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass32);
}
@Test
public void test1569() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1569");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray29 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.String str33 = cardanEulerSingularityException31.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException31.getArguments();
java.lang.String str36 = cardanEulerSingularityException31.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException38.getSuppressed();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException38.getSuppressed();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException44.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException48.getSuppressed();
java.lang.Object[] objArray52 = cardanEulerSingularityException48.getArguments();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.String str54 = cardanEulerSingularityException48.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.String str58 = cardanEulerSingularityException56.getPattern();
java.lang.Object[] objArray59 = cardanEulerSingularityException56.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray62 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException61.getArguments();
java.lang.String str64 = cardanEulerSingularityException61.getPattern();
java.lang.String str65 = cardanEulerSingularityException61.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.String str70 = cardanEulerSingularityException68.getPattern();
java.lang.Object[] objArray71 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray72 = cardanEulerSingularityException68.getArguments();
java.lang.String str73 = cardanEulerSingularityException68.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException75 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException75);
java.lang.String str77 = cardanEulerSingularityException68.getPattern();
java.lang.String str78 = cardanEulerSingularityException68.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException68);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException56.getSuppressed();
java.lang.String str81 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray84 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str85 = cardanEulerSingularityException5.getPattern();
java.lang.String str86 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Cardan angles singularity" + "'", str64, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Cardan angles singularity" + "'", str65, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "Euler angles singularity" + "'", str77, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray84);
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Euler angles singularity" + "'", str85, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str86 + "' != '" + "Euler angles singularity" + "'", str86, "Euler angles singularity");
}
@Test
public void test1570() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1570");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
}
@Test
public void test1571() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1571");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
java.lang.String str18 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException26.getSuppressed();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException26.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(throwableArray32);
}
@Test
public void test1572() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1572");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str10, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1573() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1573");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str7 = cardanEulerSingularityException5.getPattern();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str11 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
}
@Test
public void test1574() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1574");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray31 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException8.getPattern();
java.lang.String str34 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException8.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray36);
}
@Test
public void test1575() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1575");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray6 = cardanEulerSingularityException1.getArguments();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
}
@Test
public void test1576() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1576");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray18 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.String str22 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException20.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException25.getSuppressed();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException25.getSuppressed();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException25.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
java.lang.Object[] objArray42 = cardanEulerSingularityException20.getArguments();
java.lang.String str43 = cardanEulerSingularityException20.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
}
@Test
public void test1577() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1577");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray11 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str29 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray36 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException13.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Class<?> wildcardClass40 = cardanEulerSingularityException5.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass40);
}
@Test
public void test1578() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1578");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.String str11 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
}
@Test
public void test1579() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1579");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException12.getArguments();
java.lang.String str24 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
java.lang.String str31 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException43.getSuppressed();
java.lang.Object[] objArray47 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str49 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
java.lang.String str60 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.String str65 = cardanEulerSingularityException63.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException63.getArguments();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str72 = cardanEulerSingularityException63.getPattern();
java.lang.String str73 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException51.getSuppressed();
java.lang.String str76 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str78 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str80 = cardanEulerSingularityException12.getPattern();
java.lang.String str81 = cardanEulerSingularityException12.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Cardan angles singularity" + "'", str59, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "Euler angles singularity" + "'", str80, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str81, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1580() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1580");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.String str22 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
java.lang.String str29 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray31 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Object[] objArray47 = cardanEulerSingularityException37.getArguments();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException37.getSuppressed();
java.lang.Object[] objArray49 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str57 = cardanEulerSingularityException37.getPattern();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Class<?> wildcardClass59 = cardanEulerSingularityException37.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass59);
}
@Test
public void test1581() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1581");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass12 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(wildcardClass12);
}
@Test
public void test1582() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1582");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException13.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException13.getPattern();
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str28 = cardanEulerSingularityException27.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str33 = cardanEulerSingularityException32.getPattern();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException32.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str38 = cardanEulerSingularityException37.getPattern();
java.lang.Object[] objArray39 = cardanEulerSingularityException37.getArguments();
java.lang.String str40 = cardanEulerSingularityException37.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
java.lang.Object[] objArray58 = cardanEulerSingularityException55.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException60.getSuppressed();
java.lang.String str63 = cardanEulerSingularityException60.getPattern();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
java.lang.Object[] objArray65 = cardanEulerSingularityException60.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
java.lang.Object[] objArray67 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
}
@Test
public void test1583() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1583");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray23 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
java.lang.Object[] objArray30 = cardanEulerSingularityException13.getArguments();
java.lang.String str31 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str33 = cardanEulerSingularityException13.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str33, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1584() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1584");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
}
@Test
public void test1585() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1585");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
java.lang.String str18 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str27 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.String str32 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException35.getSuppressed();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException35.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
java.lang.Object[] objArray55 = cardanEulerSingularityException53.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray58 = cardanEulerSingularityException57.getArguments();
cardanEulerSingularityException53.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray60 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException62.getSuppressed();
java.lang.String str65 = cardanEulerSingularityException62.getPattern();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
java.lang.Object[] objArray67 = cardanEulerSingularityException57.getArguments();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException57.getSuppressed();
java.lang.Object[] objArray69 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException71.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException71.getSuppressed();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray78 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException80 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray81 = cardanEulerSingularityException80.getArguments();
java.lang.String str82 = cardanEulerSingularityException80.getPattern();
java.lang.Object[] objArray83 = cardanEulerSingularityException80.getArguments();
java.lang.Object[] objArray84 = cardanEulerSingularityException80.getArguments();
java.lang.String str85 = cardanEulerSingularityException80.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException87 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray88 = cardanEulerSingularityException87.getArguments();
java.lang.Throwable[] throwableArray89 = cardanEulerSingularityException87.getSuppressed();
java.lang.Throwable[] throwableArray90 = cardanEulerSingularityException87.getSuppressed();
cardanEulerSingularityException80.addSuppressed((java.lang.Throwable) cardanEulerSingularityException87);
java.lang.Object[] objArray92 = cardanEulerSingularityException80.getArguments();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.Object[] objArray94 = cardanEulerSingularityException80.getArguments();
java.lang.String str95 = cardanEulerSingularityException80.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.String str97 = cardanEulerSingularityException80.getPattern();
java.lang.Throwable[] throwableArray98 = cardanEulerSingularityException80.getSuppressed();
java.lang.String str99 = cardanEulerSingularityException80.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertNotNull(objArray81);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray81), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray81), "[]");
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Euler angles singularity" + "'", str82, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Euler angles singularity" + "'", str85, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray88);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray88), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray88), "[]");
org.junit.Assert.assertNotNull(throwableArray89);
org.junit.Assert.assertNotNull(throwableArray90);
org.junit.Assert.assertNotNull(objArray92);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray92), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray92), "[]");
org.junit.Assert.assertNotNull(objArray94);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray94), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray94), "[]");
org.junit.Assert.assertEquals("'" + str95 + "' != '" + "Euler angles singularity" + "'", str95, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str97 + "' != '" + "Euler angles singularity" + "'", str97, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray98);
org.junit.Assert.assertEquals("'" + str99 + "' != '" + "Euler angles singularity" + "'", str99, "Euler angles singularity");
}
@Test
public void test1586() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1586");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass25 = throwableArray24.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(wildcardClass25);
}
@Test
public void test1587() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1587");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray19 = cardanEulerSingularityException3.getArguments();
java.lang.Class<?> wildcardClass20 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(wildcardClass20);
}
@Test
public void test1588() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1588");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.String str17 = cardanEulerSingularityException15.getPattern();
java.lang.String str18 = cardanEulerSingularityException15.getPattern();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Object[] objArray20 = cardanEulerSingularityException15.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException22.getSuppressed();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException22.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str30 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException33.getPattern();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str45 = cardanEulerSingularityException44.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException44.getSuppressed();
java.lang.String str52 = cardanEulerSingularityException44.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
}
@Test
public void test1589() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1589");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str13 = cardanEulerSingularityException12.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
java.lang.String str15 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str18 = cardanEulerSingularityException17.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException17.getSuppressed();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray21 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Cardan angles singularity" + "'", str7, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
}
@Test
public void test1590() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1590");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException6.getSuppressed();
java.lang.Object[] objArray32 = cardanEulerSingularityException6.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
}
@Test
public void test1591() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1591");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray49 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException55.getSuppressed();
java.lang.Object[] objArray59 = cardanEulerSingularityException55.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray62 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray64 = cardanEulerSingularityException61.getArguments();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.Object[] objArray66 = cardanEulerSingularityException61.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.String str68 = cardanEulerSingularityException28.getPattern();
java.lang.Object[] objArray69 = cardanEulerSingularityException28.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
}
@Test
public void test1592() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1592");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException19.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray25);
}
@Test
public void test1593() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1593");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray45 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str50 = cardanEulerSingularityException49.getPattern();
java.lang.String str51 = cardanEulerSingularityException49.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
java.lang.Object[] objArray56 = cardanEulerSingularityException54.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
cardanEulerSingularityException54.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException54.getSuppressed();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException49.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Cardan angles singularity" + "'", str50, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Cardan angles singularity" + "'", str51, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertNotNull(throwableArray65);
}
@Test
public void test1594() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1594");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str18 = cardanEulerSingularityException13.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str18, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1595() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1595");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str24 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray40 = cardanEulerSingularityException30.getArguments();
java.lang.String str41 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray42 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
}
@Test
public void test1596() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1596");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.String str11 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray12 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
java.lang.String str17 = cardanEulerSingularityException14.getPattern();
java.lang.String str18 = cardanEulerSingularityException14.getPattern();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException14.getSuppressed();
java.lang.Object[] objArray21 = cardanEulerSingularityException14.getArguments();
java.lang.String str22 = cardanEulerSingularityException14.getPattern();
java.lang.String str23 = cardanEulerSingularityException14.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Object[] objArray25 = cardanEulerSingularityException14.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Cardan angles singularity" + "'", str22, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Cardan angles singularity" + "'", str23, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
}
@Test
public void test1597() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1597");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray11 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str29 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray36 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException13.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str42 = cardanEulerSingularityException41.getPattern();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str47 = cardanEulerSingularityException46.getPattern();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException46.getSuppressed();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Object[] objArray51 = cardanEulerSingularityException41.getArguments();
java.lang.String str52 = cardanEulerSingularityException41.getPattern();
java.lang.String str53 = cardanEulerSingularityException41.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
}
@Test
public void test1598() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1598");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray38 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException40.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException40.getSuppressed();
java.lang.String str48 = cardanEulerSingularityException40.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.String str52 = cardanEulerSingularityException50.getPattern();
java.lang.Object[] objArray53 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray54 = cardanEulerSingularityException50.getArguments();
java.lang.String str55 = cardanEulerSingularityException50.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray60 = cardanEulerSingularityException57.getArguments();
java.lang.Object[] objArray61 = cardanEulerSingularityException57.getArguments();
java.lang.Object[] objArray62 = cardanEulerSingularityException57.getArguments();
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException57.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray67 = cardanEulerSingularityException66.getArguments();
java.lang.String str68 = cardanEulerSingularityException66.getPattern();
java.lang.Object[] objArray69 = cardanEulerSingularityException66.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray72 = cardanEulerSingularityException71.getArguments();
java.lang.Object[] objArray73 = cardanEulerSingularityException71.getArguments();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
java.lang.Object[] objArray75 = cardanEulerSingularityException71.getArguments();
java.lang.Throwable[] throwableArray76 = cardanEulerSingularityException71.getSuppressed();
java.lang.Throwable[] throwableArray77 = cardanEulerSingularityException71.getSuppressed();
java.lang.String str78 = cardanEulerSingularityException71.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
java.lang.String str80 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertNotNull(throwableArray76);
org.junit.Assert.assertNotNull(throwableArray77);
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Cardan angles singularity" + "'", str78, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str80, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1599() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1599");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.String str10 = cardanEulerSingularityException7.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException27.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str41 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray45 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray48 = cardanEulerSingularityException47.getArguments();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
java.lang.String str50 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException47.getSuppressed();
java.lang.String str52 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException47.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
java.lang.String str57 = cardanEulerSingularityException55.getPattern();
java.lang.Object[] objArray58 = cardanEulerSingularityException55.getArguments();
java.lang.Object[] objArray59 = cardanEulerSingularityException55.getArguments();
java.lang.String str60 = cardanEulerSingularityException55.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException62.getSuppressed();
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException62.getSuppressed();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray70 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException72.getSuppressed();
java.lang.Object[] objArray76 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.Object[] objArray79 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertNotNull(throwableArray65);
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
}
@Test
public void test1600() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1600");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str25 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str28 = cardanEulerSingularityException27.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.String str38 = cardanEulerSingularityException31.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.String str42 = cardanEulerSingularityException40.getPattern();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException40.getSuppressed();
java.lang.Object[] objArray45 = cardanEulerSingularityException40.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.String str48 = cardanEulerSingularityException27.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str48, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1601() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1601");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.String str6 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str16 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray17 = cardanEulerSingularityException8.getArguments();
java.lang.Object[] objArray18 = cardanEulerSingularityException8.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException20.getSuppressed();
java.lang.String str28 = cardanEulerSingularityException20.getPattern();
java.lang.String str29 = cardanEulerSingularityException20.getPattern();
java.lang.String str30 = cardanEulerSingularityException20.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException34.getArguments();
java.lang.String str38 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str41 = cardanEulerSingularityException34.getPattern();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Cardan angles singularity" + "'", str38, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
}
@Test
public void test1602() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1602");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray11 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str29 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray36 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException13.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str42 = cardanEulerSingularityException41.getPattern();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str47 = cardanEulerSingularityException46.getPattern();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException46.getSuppressed();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Class<?> wildcardClass51 = cardanEulerSingularityException13.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(wildcardClass51);
}
@Test
public void test1603() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1603");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException21.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str31 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray35 = cardanEulerSingularityException21.getArguments();
java.lang.Class<?> wildcardClass36 = cardanEulerSingularityException21.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(wildcardClass36);
}
@Test
public void test1604() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1604");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException16.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException22.getSuppressed();
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str31 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException45.getPattern();
java.lang.String str48 = cardanEulerSingularityException45.getPattern();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.Object[] objArray50 = cardanEulerSingularityException45.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException52.getSuppressed();
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException52.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str60 = cardanEulerSingularityException59.getPattern();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException63.getSuppressed();
java.lang.String str66 = cardanEulerSingularityException63.getPattern();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException63.getSuppressed();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
java.lang.Throwable[] throwableArray69 = cardanEulerSingularityException63.getSuppressed();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Object[] objArray73 = cardanEulerSingularityException52.getArguments();
java.lang.Object[] objArray74 = cardanEulerSingularityException52.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(throwableArray65);
org.junit.Assert.assertEquals("'" + str66 + "' != '" + "Euler angles singularity" + "'", str66, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray69);
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
}
@Test
public void test1605() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1605");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray49 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray50 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray51 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException28.getArguments();
java.lang.Class<?> wildcardClass54 = cardanEulerSingularityException28.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(wildcardClass54);
}
@Test
public void test1606() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1606");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Object[] objArray17 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Class<?> wildcardClass23 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(wildcardClass23);
}
@Test
public void test1607() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1607");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException16.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.Object[] objArray24 = cardanEulerSingularityException22.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.String str32 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str37 = cardanEulerSingularityException3.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str37, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1608() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1608");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray23 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
java.lang.Object[] objArray30 = cardanEulerSingularityException13.getArguments();
java.lang.String str31 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray33 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray35 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
}
@Test
public void test1609() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1609");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException5.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.String str23 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.String str27 = cardanEulerSingularityException15.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Object[] objArray29 = cardanEulerSingularityException15.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Cardan angles singularity" + "'", str27, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
}
@Test
public void test1610() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1610");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
java.lang.String str35 = cardanEulerSingularityException31.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.String str40 = cardanEulerSingularityException38.getPattern();
java.lang.Object[] objArray41 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException38.getArguments();
java.lang.String str43 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException38.getPattern();
java.lang.String str48 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.String str53 = cardanEulerSingularityException18.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str53, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1611() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1611");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray10 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray35 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str38 = cardanEulerSingularityException37.getPattern();
java.lang.Object[] objArray39 = cardanEulerSingularityException37.getArguments();
java.lang.String str40 = cardanEulerSingularityException37.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Object[] objArray49 = cardanEulerSingularityException47.getArguments();
java.lang.String str50 = cardanEulerSingularityException47.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str53 = cardanEulerSingularityException52.getPattern();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException52.getSuppressed();
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
java.lang.String str57 = cardanEulerSingularityException37.getPattern();
java.lang.String str58 = cardanEulerSingularityException37.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
java.lang.String str62 = cardanEulerSingularityException60.getPattern();
java.lang.Object[] objArray63 = cardanEulerSingularityException60.getArguments();
java.lang.Object[] objArray64 = cardanEulerSingularityException60.getArguments();
java.lang.String str65 = cardanEulerSingularityException60.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Euler angles singularity" + "'", str62, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
}
@Test
public void test1612() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1612");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(throwableArray38);
}
@Test
public void test1613() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1613");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException1.getArguments();
java.lang.Class<?> wildcardClass22 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(wildcardClass22);
}
@Test
public void test1614() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1614");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Object[] objArray28 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str37 = cardanEulerSingularityException18.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str37, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1615() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1615");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException1.getArguments();
java.lang.String str27 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str27, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1616() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1616");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str33 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray35 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException41.getSuppressed();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException41.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray48 = cardanEulerSingularityException47.getArguments();
java.lang.Object[] objArray49 = cardanEulerSingularityException47.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
java.lang.Object[] objArray57 = cardanEulerSingularityException41.getArguments();
java.lang.String str58 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException13.getSuppressed();
java.lang.Object[] objArray61 = cardanEulerSingularityException13.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Cardan angles singularity" + "'", str58, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
}
@Test
public void test1617() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1617");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str28 = cardanEulerSingularityException27.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray39 = cardanEulerSingularityException35.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Cardan angles singularity" + "'", str36, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
}
@Test
public void test1618() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1618");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.String str27 = cardanEulerSingularityException24.getPattern();
java.lang.String str28 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException31.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.Object[] objArray39 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException24.getSuppressed();
java.lang.Object[] objArray51 = cardanEulerSingularityException24.getArguments();
java.lang.String str52 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException54.getSuppressed();
java.lang.String str57 = cardanEulerSingularityException54.getPattern();
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException54.getSuppressed();
java.lang.String str59 = cardanEulerSingularityException54.getPattern();
java.lang.String str60 = cardanEulerSingularityException54.getPattern();
java.lang.String str61 = cardanEulerSingularityException54.getPattern();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Cardan angles singularity" + "'", str27, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Cardan angles singularity" + "'", str52, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
}
@Test
public void test1619() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1619");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str31 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException28.getPattern();
java.lang.String str34 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.String str39 = cardanEulerSingularityException37.getPattern();
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
java.lang.String str46 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
java.lang.String str51 = cardanEulerSingularityException49.getPattern();
java.lang.Object[] objArray52 = cardanEulerSingularityException49.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException49.getArguments();
java.lang.String str54 = cardanEulerSingularityException49.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
java.lang.String str58 = cardanEulerSingularityException49.getPattern();
java.lang.String str59 = cardanEulerSingularityException49.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException37.getSuppressed();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException37.getSuppressed();
java.lang.String str63 = cardanEulerSingularityException37.getPattern();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Cardan angles singularity" + "'", str45, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Cardan angles singularity" + "'", str46, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
}
@Test
public void test1620() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1620");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException4 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str5 = cardanEulerSingularityException4.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException4.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException4);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str10 = cardanEulerSingularityException9.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.String str12 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException14.getSuppressed();
java.lang.String str22 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
java.lang.String str29 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException14.getSuppressed();
java.lang.Class<?> wildcardClass36 = throwableArray35.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(wildcardClass36);
}
@Test
public void test1621() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1621");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray29 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.String str32 = cardanEulerSingularityException24.getPattern();
java.lang.String str33 = cardanEulerSingularityException24.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Cardan angles singularity" + "'", str12, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
}
@Test
public void test1622() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1622");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException18.getSuppressed();
java.lang.Class<?> wildcardClass25 = cardanEulerSingularityException18.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(wildcardClass25);
}
@Test
public void test1623() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1623");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray9 = cardanEulerSingularityException6.getArguments();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException6.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Cardan angles singularity" + "'", str7, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str13, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1624() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1624");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str32 = cardanEulerSingularityException31.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str37 = cardanEulerSingularityException36.getPattern();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray46 = cardanEulerSingularityException45.getArguments();
java.lang.Object[] objArray47 = cardanEulerSingularityException45.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Object[] objArray52 = cardanEulerSingularityException49.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException54.getSuppressed();
java.lang.String str57 = cardanEulerSingularityException54.getPattern();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Object[] objArray59 = cardanEulerSingularityException54.getArguments();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException21.getSuppressed();
java.lang.Class<?> wildcardClass63 = cardanEulerSingularityException21.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertNotNull(wildcardClass63);
}
@Test
public void test1625() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1625");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str33 = cardanEulerSingularityException32.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str38 = cardanEulerSingularityException37.getPattern();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException37.getSuppressed();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.String str55 = cardanEulerSingularityException53.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str59 = cardanEulerSingularityException58.getPattern();
java.lang.Object[] objArray60 = cardanEulerSingularityException58.getArguments();
java.lang.String str61 = cardanEulerSingularityException58.getPattern();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException58.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException64.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray71 = cardanEulerSingularityException70.getArguments();
java.lang.Object[] objArray72 = cardanEulerSingularityException70.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException74 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException76 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException76);
cardanEulerSingularityException70.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException64.getSuppressed();
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
java.lang.String str84 = cardanEulerSingularityException1.getPattern();
java.lang.String str85 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray86 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Cardan angles singularity" + "'", str84, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Cardan angles singularity" + "'", str85, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
}
@Test
public void test1626() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1626");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str12 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException6.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Cardan angles singularity" + "'", str12, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Cardan angles singularity" + "'", str15, "Cardan angles singularity");
}
@Test
public void test1627() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1627");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException3.getPattern();
java.lang.String str10 = cardanEulerSingularityException3.getPattern();
java.lang.Class<?> wildcardClass11 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass11);
}
@Test
public void test1628() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1628");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException4 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str5 = cardanEulerSingularityException4.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException4.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException4);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str10 = cardanEulerSingularityException9.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.String str12 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass14 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertNotNull(wildcardClass14);
}
@Test
public void test1629() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1629");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str32 = cardanEulerSingularityException31.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str37 = cardanEulerSingularityException36.getPattern();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray46 = cardanEulerSingularityException45.getArguments();
java.lang.Object[] objArray47 = cardanEulerSingularityException45.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Object[] objArray52 = cardanEulerSingularityException49.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException54.getSuppressed();
java.lang.String str57 = cardanEulerSingularityException54.getPattern();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Object[] objArray59 = cardanEulerSingularityException54.getArguments();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException21.getSuppressed();
java.lang.String str63 = cardanEulerSingularityException21.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
}
@Test
public void test1630() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1630");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str10 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str14 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray16 = cardanEulerSingularityException8.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
}
@Test
public void test1631() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1631");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException21.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException26.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.String str34 = cardanEulerSingularityException32.getPattern();
java.lang.Object[] objArray35 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException37.getSuppressed();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException37.getSuppressed();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException37.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
java.lang.Object[] objArray45 = cardanEulerSingularityException43.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
java.lang.Object[] objArray57 = cardanEulerSingularityException55.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray60 = cardanEulerSingularityException59.getArguments();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
java.lang.Object[] objArray62 = cardanEulerSingularityException59.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException64.getSuppressed();
java.lang.String str67 = cardanEulerSingularityException64.getPattern();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.Object[] objArray69 = cardanEulerSingularityException59.getArguments();
java.lang.Throwable[] throwableArray70 = cardanEulerSingularityException59.getSuppressed();
java.lang.Object[] objArray71 = cardanEulerSingularityException59.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException75 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException75);
java.lang.Throwable[] throwableArray77 = cardanEulerSingularityException73.getSuppressed();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
java.lang.Object[] objArray80 = cardanEulerSingularityException59.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException82 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray83 = cardanEulerSingularityException82.getArguments();
java.lang.String str84 = cardanEulerSingularityException82.getPattern();
java.lang.Object[] objArray85 = cardanEulerSingularityException82.getArguments();
java.lang.Object[] objArray86 = cardanEulerSingularityException82.getArguments();
java.lang.String str87 = cardanEulerSingularityException82.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException89 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray90 = cardanEulerSingularityException89.getArguments();
java.lang.Throwable[] throwableArray91 = cardanEulerSingularityException89.getSuppressed();
java.lang.Throwable[] throwableArray92 = cardanEulerSingularityException89.getSuppressed();
cardanEulerSingularityException82.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
java.lang.Object[] objArray94 = cardanEulerSingularityException82.getArguments();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException82);
java.lang.String str96 = cardanEulerSingularityException59.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Euler angles singularity" + "'", str67, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(throwableArray70);
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(throwableArray77);
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray85);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray85), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray85), "[]");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray90);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray90), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray90), "[]");
org.junit.Assert.assertNotNull(throwableArray91);
org.junit.Assert.assertNotNull(throwableArray92);
org.junit.Assert.assertNotNull(objArray94);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray94), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray94), "[]");
org.junit.Assert.assertEquals("'" + str96 + "' != '" + "Euler angles singularity" + "'", str96, "Euler angles singularity");
}
@Test
public void test1632() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1632");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray26 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException34.getSuppressed();
java.lang.Object[] objArray37 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.String str43 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str45 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str47 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.String str50 = cardanEulerSingularityException41.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray53 = cardanEulerSingularityException52.getArguments();
java.lang.String str54 = cardanEulerSingularityException52.getPattern();
java.lang.Object[] objArray55 = cardanEulerSingularityException52.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray58 = cardanEulerSingularityException57.getArguments();
java.lang.Object[] objArray59 = cardanEulerSingularityException57.getArguments();
java.lang.String str60 = cardanEulerSingularityException57.getPattern();
java.lang.String str61 = cardanEulerSingularityException57.getPattern();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException64.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray71 = cardanEulerSingularityException70.getArguments();
java.lang.Object[] objArray72 = cardanEulerSingularityException70.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException74 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException76 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException76);
cardanEulerSingularityException70.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException64.getSuppressed();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.String str82 = cardanEulerSingularityException64.getPattern();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.Object[] objArray84 = cardanEulerSingularityException64.getArguments();
java.lang.String str85 = cardanEulerSingularityException64.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Cardan angles singularity" + "'", str61, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Cardan angles singularity" + "'", str82, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Cardan angles singularity" + "'", str85, "Cardan angles singularity");
}
@Test
public void test1633() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1633");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException30.getSuppressed();
java.lang.Object[] objArray34 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Object[] objArray42 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException30.getSuppressed();
java.lang.Object[] objArray44 = cardanEulerSingularityException30.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
}
@Test
public void test1634() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1634");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Object[] objArray20 = cardanEulerSingularityException5.getArguments();
java.lang.String str21 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException27.getSuppressed();
java.lang.Object[] objArray31 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException33.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException50.getSuppressed();
java.lang.String str53 = cardanEulerSingularityException50.getPattern();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException50.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException50.getPattern();
java.lang.String str56 = cardanEulerSingularityException50.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException50.getSuppressed();
java.lang.String str59 = cardanEulerSingularityException50.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.String str61 = cardanEulerSingularityException50.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray65 = cardanEulerSingularityException63.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray68 = cardanEulerSingularityException67.getArguments();
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
java.lang.Object[] objArray70 = cardanEulerSingularityException67.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
java.lang.Throwable[] throwableArray74 = cardanEulerSingularityException72.getSuppressed();
java.lang.String str75 = cardanEulerSingularityException72.getPattern();
cardanEulerSingularityException67.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.Object[] objArray77 = cardanEulerSingularityException67.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException79 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray80 = cardanEulerSingularityException79.getArguments();
java.lang.Object[] objArray81 = cardanEulerSingularityException79.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException83 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray84 = cardanEulerSingularityException83.getArguments();
cardanEulerSingularityException79.addSuppressed((java.lang.Throwable) cardanEulerSingularityException83);
java.lang.Throwable[] throwableArray86 = cardanEulerSingularityException79.getSuppressed();
java.lang.String str87 = cardanEulerSingularityException79.getPattern();
java.lang.String str88 = cardanEulerSingularityException79.getPattern();
java.lang.String str89 = cardanEulerSingularityException79.getPattern();
cardanEulerSingularityException67.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException92 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray93 = cardanEulerSingularityException92.getArguments();
cardanEulerSingularityException79.addSuppressed((java.lang.Throwable) cardanEulerSingularityException92);
java.lang.String str95 = cardanEulerSingularityException79.getPattern();
java.lang.Object[] objArray96 = cardanEulerSingularityException79.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
java.lang.String str98 = cardanEulerSingularityException79.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(throwableArray74);
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Euler angles singularity" + "'", str75, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(objArray81);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray81), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray81), "[]");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertNotNull(throwableArray86);
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str88 + "' != '" + "Euler angles singularity" + "'", str88, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str89 + "' != '" + "Euler angles singularity" + "'", str89, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray93);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray93), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray93), "[]");
org.junit.Assert.assertEquals("'" + str95 + "' != '" + "Euler angles singularity" + "'", str95, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray96);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray96), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray96), "[]");
org.junit.Assert.assertEquals("'" + str98 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str98, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1635() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1635");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException14.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException33.getArguments();
java.lang.String str38 = cardanEulerSingularityException33.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Object[] objArray45 = cardanEulerSingularityException33.getArguments();
java.lang.String str46 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
java.lang.Object[] objArray51 = cardanEulerSingularityException49.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray58 = cardanEulerSingularityException57.getArguments();
java.lang.Object[] objArray59 = cardanEulerSingularityException57.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException61.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException57.getSuppressed();
cardanEulerSingularityException53.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException69 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray70 = cardanEulerSingularityException69.getArguments();
java.lang.Object[] objArray71 = cardanEulerSingularityException69.getArguments();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException69);
java.lang.Throwable[] throwableArray73 = cardanEulerSingularityException69.getSuppressed();
java.lang.Object[] objArray74 = cardanEulerSingularityException69.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException69);
java.lang.Object[] objArray76 = cardanEulerSingularityException69.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(throwableArray73);
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
}
@Test
public void test1636() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1636");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
java.lang.String str24 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException1.getArguments();
java.lang.String str26 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
}
@Test
public void test1637() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1637");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.String str10 = cardanEulerSingularityException7.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException27.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str41 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray45 = cardanEulerSingularityException13.getArguments();
java.lang.String str46 = cardanEulerSingularityException13.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Cardan angles singularity" + "'", str46, "Cardan angles singularity");
}
@Test
public void test1638() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1638");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str31 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.String str40 = cardanEulerSingularityException33.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.String str44 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
java.lang.String str47 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
}
@Test
public void test1639() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1639");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.Class<?> wildcardClass6 = objArray5.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Cardan angles singularity" + "'", str2, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Cardan angles singularity" + "'", str3, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(wildcardClass6);
}
@Test
public void test1640() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1640");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException12.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException12.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException12.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray21 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
}
@Test
public void test1641() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1641");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Object[] objArray20 = cardanEulerSingularityException15.getArguments();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException15.getSuppressed();
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException32.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str45 = cardanEulerSingularityException44.getPattern();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException44.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Object[] objArray50 = cardanEulerSingularityException44.getArguments();
java.lang.Class<?> wildcardClass51 = cardanEulerSingularityException44.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(wildcardClass51);
}
@Test
public void test1642() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1642");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException5.getArguments();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException5.getSuppressed();
java.lang.Class<?> wildcardClass19 = cardanEulerSingularityException5.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(wildcardClass19);
}
@Test
public void test1643() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1643");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass4 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(wildcardClass4);
}
@Test
public void test1644() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1644");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException11.getPattern();
java.lang.String str18 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException11.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.String str25 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException23.getArguments();
java.lang.String str28 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray40 = cardanEulerSingularityException38.getArguments();
java.lang.String str41 = cardanEulerSingularityException38.getPattern();
java.lang.String str42 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray46 = cardanEulerSingularityException45.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException45.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException45.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str63 = cardanEulerSingularityException45.getPattern();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException3.getSuppressed();
java.lang.Class<?> wildcardClass67 = throwableArray66.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Cardan angles singularity" + "'", str42, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Cardan angles singularity" + "'", str63, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(wildcardClass67);
}
@Test
public void test1645() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1645");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Object[] objArray14 = cardanEulerSingularityException9.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.String str17 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str17, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1646() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1646");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException50.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException54.getSuppressed();
java.lang.String str58 = cardanEulerSingularityException54.getPattern();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException54.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Object[] objArray61 = cardanEulerSingularityException6.getArguments();
java.lang.String str62 = cardanEulerSingularityException6.getPattern();
java.lang.Class<?> wildcardClass63 = cardanEulerSingularityException6.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray59);
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Cardan angles singularity" + "'", str62, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass63);
}
@Test
public void test1647() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1647");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
java.lang.String str25 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str28 = cardanEulerSingularityException27.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException27.getSuppressed();
java.lang.Object[] objArray32 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str46 = cardanEulerSingularityException45.getPattern();
java.lang.Object[] objArray47 = cardanEulerSingularityException45.getArguments();
java.lang.String str48 = cardanEulerSingularityException45.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str51 = cardanEulerSingularityException50.getPattern();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException50.getSuppressed();
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException35.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(throwableArray56);
}
@Test
public void test1648() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1648");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.String str14 = cardanEulerSingularityException12.getPattern();
java.lang.String str15 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str26 = cardanEulerSingularityException19.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.String str30 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str35 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Cardan angles singularity" + "'", str5, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Cardan angles singularity" + "'", str6, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str35, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1649() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1649");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Object[] objArray5 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str8 = cardanEulerSingularityException7.getPattern();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
java.lang.String str10 = cardanEulerSingularityException7.getPattern();
java.lang.String str11 = cardanEulerSingularityException7.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str21 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
java.lang.String str23 = cardanEulerSingularityException20.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException25.getSuppressed();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException20.getSuppressed();
java.lang.Object[] objArray45 = cardanEulerSingularityException20.getArguments();
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str47 = cardanEulerSingularityException7.getPattern();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Object[] objArray49 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
java.lang.String str60 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.String str65 = cardanEulerSingularityException63.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException63.getArguments();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str72 = cardanEulerSingularityException63.getPattern();
java.lang.String str73 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Cardan angles singularity" + "'", str59, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray75);
}
@Test
public void test1650() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1650");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException6.getSuppressed();
java.lang.Object[] objArray13 = cardanEulerSingularityException6.getArguments();
java.lang.String str14 = cardanEulerSingularityException6.getPattern();
java.lang.String str15 = cardanEulerSingularityException6.getPattern();
java.lang.String str16 = cardanEulerSingularityException6.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
java.lang.String str22 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray24 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
java.lang.String str29 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str32 = cardanEulerSingularityException31.getPattern();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.String str35 = cardanEulerSingularityException26.getPattern();
java.lang.String str36 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str41 = cardanEulerSingularityException18.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Cardan angles singularity" + "'", str14, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Cardan angles singularity" + "'", str15, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Cardan angles singularity" + "'", str16, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Cardan angles singularity" + "'", str21, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Cardan angles singularity" + "'", str22, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
}
@Test
public void test1651() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1651");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException9.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException9.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException9.getSuppressed();
java.lang.String str14 = cardanEulerSingularityException9.getPattern();
java.lang.String str15 = cardanEulerSingularityException9.getPattern();
java.lang.String str16 = cardanEulerSingularityException9.getPattern();
java.lang.String str17 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray18 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.String str22 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException20.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
java.lang.String str29 = cardanEulerSingularityException25.getPattern();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException32.getSuppressed();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException32.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException32.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray40 = cardanEulerSingularityException38.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException32.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException32.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray53 = cardanEulerSingularityException52.getArguments();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException52.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException52.getPattern();
java.lang.Object[] objArray56 = cardanEulerSingularityException52.getArguments();
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException52.getSuppressed();
java.lang.Object[] objArray58 = cardanEulerSingularityException52.getArguments();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException52.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray62 = cardanEulerSingularityException61.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException61.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException65 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException65.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
cardanEulerSingularityException61.addSuppressed((java.lang.Throwable) cardanEulerSingularityException65);
java.lang.String str70 = cardanEulerSingularityException61.getPattern();
java.lang.String str71 = cardanEulerSingularityException61.getPattern();
java.lang.Throwable[] throwableArray72 = cardanEulerSingularityException61.getSuppressed();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.String str77 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(throwableArray59);
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str71 + "' != '" + "Euler angles singularity" + "'", str71, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray72);
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str77, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1652() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1652");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
java.lang.String str35 = cardanEulerSingularityException31.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.String str40 = cardanEulerSingularityException38.getPattern();
java.lang.Object[] objArray41 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException38.getArguments();
java.lang.String str43 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException38.getPattern();
java.lang.String str48 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray54 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray55 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException26.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
}
@Test
public void test1653() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1653");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.String str33 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException17.getArguments();
java.lang.String str36 = cardanEulerSingularityException17.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str36, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1654() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1654");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException26.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str36 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray40 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.String str43 = cardanEulerSingularityException26.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str43, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1655() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1655");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.String str10 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray11 = cardanEulerSingularityException8.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
java.lang.String str17 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str38 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
java.lang.String str43 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException40.getSuppressed();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException40.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray48 = cardanEulerSingularityException47.getArguments();
java.lang.Object[] objArray49 = cardanEulerSingularityException47.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str54 = cardanEulerSingularityException47.getPattern();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.String str58 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray59 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Cardan angles singularity" + "'", str16, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Cardan angles singularity" + "'", str38, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Cardan angles singularity" + "'", str58, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
}
@Test
public void test1656() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1656");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str11 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
java.lang.String str17 = cardanEulerSingularityException13.getPattern();
java.lang.String str18 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.Object[] objArray24 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException32.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.String str37 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Object[] objArray46 = cardanEulerSingularityException43.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException48.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException48.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Object[] objArray53 = cardanEulerSingularityException43.getArguments();
java.lang.String str54 = cardanEulerSingularityException43.getPattern();
java.lang.Object[] objArray55 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str58 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
}
@Test
public void test1657() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1657");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str24 = cardanEulerSingularityException1.getPattern();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
}
@Test
public void test1658() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1658");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Object[] objArray46 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray49 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray53 = cardanEulerSingularityException52.getArguments();
java.lang.Object[] objArray54 = cardanEulerSingularityException52.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
java.lang.Object[] objArray59 = cardanEulerSingularityException56.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray62 = cardanEulerSingularityException61.getArguments();
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException61.getSuppressed();
java.lang.String str64 = cardanEulerSingularityException61.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.Object[] objArray66 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException56.getArguments();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException56.getSuppressed();
java.lang.String str69 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
java.lang.Throwable[] throwableArray74 = cardanEulerSingularityException72.getSuppressed();
java.lang.String str75 = cardanEulerSingularityException72.getPattern();
java.lang.String str76 = cardanEulerSingularityException72.getPattern();
java.lang.Throwable[] throwableArray77 = cardanEulerSingularityException72.getSuppressed();
java.lang.Object[] objArray78 = cardanEulerSingularityException72.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException80 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str81 = cardanEulerSingularityException80.getPattern();
java.lang.Object[] objArray82 = cardanEulerSingularityException80.getArguments();
java.lang.String str83 = cardanEulerSingularityException80.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException85 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str86 = cardanEulerSingularityException85.getPattern();
java.lang.Throwable[] throwableArray87 = cardanEulerSingularityException85.getSuppressed();
cardanEulerSingularityException80.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
java.lang.String str89 = cardanEulerSingularityException80.getPattern();
java.lang.String str90 = cardanEulerSingularityException80.getPattern();
java.lang.Throwable[] throwableArray91 = cardanEulerSingularityException80.getSuppressed();
cardanEulerSingularityException72.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
java.lang.Throwable[] throwableArray93 = cardanEulerSingularityException80.getSuppressed();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException80);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Euler angles singularity" + "'", str64, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertEquals("'" + str69 + "' != '" + "Euler angles singularity" + "'", str69, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(throwableArray74);
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Cardan angles singularity" + "'", str75, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Cardan angles singularity" + "'", str76, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray77);
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertEquals("'" + str83 + "' != '" + "Euler angles singularity" + "'", str83, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str86 + "' != '" + "Euler angles singularity" + "'", str86, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray87);
org.junit.Assert.assertEquals("'" + str89 + "' != '" + "Euler angles singularity" + "'", str89, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Euler angles singularity" + "'", str90, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray91);
org.junit.Assert.assertNotNull(throwableArray93);
}
@Test
public void test1659() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1659");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException12.getArguments();
java.lang.Class<?> wildcardClass24 = cardanEulerSingularityException12.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(wildcardClass24);
}
@Test
public void test1660() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1660");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException18.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
}
@Test
public void test1661() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1661");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
}
@Test
public void test1662() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1662");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException5.getArguments();
java.lang.String str24 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str29 = cardanEulerSingularityException26.getPattern();
java.lang.String str30 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray32 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str35 = cardanEulerSingularityException34.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
java.lang.String str37 = cardanEulerSingularityException34.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str40 = cardanEulerSingularityException39.getPattern();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException39.getSuppressed();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
java.lang.String str43 = cardanEulerSingularityException34.getPattern();
java.lang.String str44 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str50 = cardanEulerSingularityException49.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str53 = cardanEulerSingularityException52.getPattern();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException52.getSuppressed();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str58 = cardanEulerSingularityException57.getPattern();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.String str60 = cardanEulerSingularityException49.getPattern();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException49.getSuppressed();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException49.getSuppressed();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.String str64 = cardanEulerSingularityException49.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Cardan angles singularity" + "'", str30, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Cardan angles singularity" + "'", str58, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Euler angles singularity" + "'", str64, "Euler angles singularity");
}
@Test
public void test1663() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1663");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str19 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str19, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1664() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1664");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.String str11 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray12 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException9.getArguments();
java.lang.String str14 = cardanEulerSingularityException9.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.Object[] objArray19 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException3.getPattern();
java.lang.Class<?> wildcardClass22 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass22);
}
@Test
public void test1665() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1665");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException10.getArguments();
java.lang.String str16 = cardanEulerSingularityException10.getPattern();
java.lang.Object[] objArray17 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException10.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
}
@Test
public void test1666() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1666");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException7.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Object[] objArray26 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
java.lang.String str31 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray33 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray40 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException23.getArguments();
java.lang.String str42 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException44.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Object[] objArray51 = cardanEulerSingularityException48.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException53.getSuppressed();
java.lang.String str56 = cardanEulerSingularityException53.getPattern();
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.Object[] objArray58 = cardanEulerSingularityException48.getArguments();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException48.getSuppressed();
java.lang.Object[] objArray60 = cardanEulerSingularityException48.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException62.getSuppressed();
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException69 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray70 = cardanEulerSingularityException69.getArguments();
java.lang.Object[] objArray71 = cardanEulerSingularityException69.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
cardanEulerSingularityException69.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Throwable[] throwableArray76 = cardanEulerSingularityException73.getSuppressed();
java.lang.Object[] objArray77 = cardanEulerSingularityException73.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException79 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray80 = cardanEulerSingularityException79.getArguments();
java.lang.Object[] objArray81 = cardanEulerSingularityException79.getArguments();
java.lang.Object[] objArray82 = cardanEulerSingularityException79.getArguments();
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
java.lang.String str86 = cardanEulerSingularityException23.getPattern();
java.lang.String str87 = cardanEulerSingularityException23.getPattern();
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Throwable[] throwableArray89 = cardanEulerSingularityException7.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(throwableArray59);
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(throwableArray76);
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(objArray81);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray81), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray81), "[]");
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertEquals("'" + str86 + "' != '" + "Euler angles singularity" + "'", str86, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray89);
}
@Test
public void test1667() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1667");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Object[] objArray46 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException36.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
java.lang.String str54 = cardanEulerSingularityException51.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
java.lang.Object[] objArray66 = cardanEulerSingularityException64.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException68);
java.lang.Throwable[] throwableArray73 = cardanEulerSingularityException64.getSuppressed();
cardanEulerSingularityException60.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException76 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray77 = cardanEulerSingularityException76.getArguments();
java.lang.Object[] objArray78 = cardanEulerSingularityException76.getArguments();
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException76);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException64.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException83 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray84 = cardanEulerSingularityException83.getArguments();
java.lang.String str85 = cardanEulerSingularityException83.getPattern();
java.lang.Object[] objArray86 = cardanEulerSingularityException83.getArguments();
java.lang.Object[] objArray87 = cardanEulerSingularityException83.getArguments();
java.lang.String str88 = cardanEulerSingularityException83.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException90 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray91 = cardanEulerSingularityException90.getArguments();
java.lang.Throwable[] throwableArray92 = cardanEulerSingularityException90.getSuppressed();
java.lang.Throwable[] throwableArray93 = cardanEulerSingularityException90.getSuppressed();
cardanEulerSingularityException83.addSuppressed((java.lang.Throwable) cardanEulerSingularityException90);
java.lang.Object[] objArray95 = cardanEulerSingularityException83.getArguments();
java.lang.String str96 = cardanEulerSingularityException83.getPattern();
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException83);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException83);
java.lang.Object[] objArray99 = cardanEulerSingularityException83.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Cardan angles singularity" + "'", str54, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(throwableArray73);
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Euler angles singularity" + "'", str85, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertNotNull(objArray87);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray87), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray87), "[]");
org.junit.Assert.assertEquals("'" + str88 + "' != '" + "Euler angles singularity" + "'", str88, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray91);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray91), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray91), "[]");
org.junit.Assert.assertNotNull(throwableArray92);
org.junit.Assert.assertNotNull(throwableArray93);
org.junit.Assert.assertNotNull(objArray95);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray95), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray95), "[]");
org.junit.Assert.assertEquals("'" + str96 + "' != '" + "Euler angles singularity" + "'", str96, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray99);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray99), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray99), "[]");
}
@Test
public void test1668() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1668");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
java.lang.String str35 = cardanEulerSingularityException31.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.String str40 = cardanEulerSingularityException38.getPattern();
java.lang.Object[] objArray41 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException38.getArguments();
java.lang.String str43 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException38.getPattern();
java.lang.String str48 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray54 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str57 = cardanEulerSingularityException56.getPattern();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str62 = cardanEulerSingularityException61.getPattern();
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException61.getSuppressed();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str67 = cardanEulerSingularityException66.getPattern();
java.lang.Object[] objArray68 = cardanEulerSingularityException66.getArguments();
java.lang.String str69 = cardanEulerSingularityException66.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str72 = cardanEulerSingularityException71.getPattern();
java.lang.Throwable[] throwableArray73 = cardanEulerSingularityException71.getSuppressed();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
java.lang.String str76 = cardanEulerSingularityException56.getPattern();
java.lang.String str77 = cardanEulerSingularityException56.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException79 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray80 = cardanEulerSingularityException79.getArguments();
java.lang.String str81 = cardanEulerSingularityException79.getPattern();
java.lang.Object[] objArray82 = cardanEulerSingularityException79.getArguments();
java.lang.Object[] objArray83 = cardanEulerSingularityException79.getArguments();
java.lang.String str84 = cardanEulerSingularityException79.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
java.lang.Throwable[] throwableArray86 = cardanEulerSingularityException56.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
java.lang.Throwable[] throwableArray88 = cardanEulerSingularityException56.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Euler angles singularity" + "'", str62, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Euler angles singularity" + "'", str67, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertEquals("'" + str69 + "' != '" + "Euler angles singularity" + "'", str69, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray73);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "Euler angles singularity" + "'", str77, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray86);
org.junit.Assert.assertNotNull(throwableArray88);
}
@Test
public void test1669() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1669");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str11 = cardanEulerSingularityException5.getPattern();
java.lang.String str12 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
}
@Test
public void test1670() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1670");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str34 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray35 = cardanEulerSingularityException18.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
}
@Test
public void test1671() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1671");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException24.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray41 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Object[] objArray43 = cardanEulerSingularityException19.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
}
@Test
public void test1672() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1672");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray32 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str37 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray39 = cardanEulerSingularityException34.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str42 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
}
@Test
public void test1673() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1673");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray27 = cardanEulerSingularityException17.getArguments();
java.lang.String str28 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.String str44 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray45 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException42.getArguments();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Object[] objArray48 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray49 = cardanEulerSingularityException42.getArguments();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.String str51 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray52 = cardanEulerSingularityException42.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
}
@Test
public void test1674() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1674");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str23 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
}
@Test
public void test1675() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1675");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException23.getSuppressed();
java.lang.String str31 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException33.getArguments();
java.lang.String str38 = cardanEulerSingularityException33.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Object[] objArray43 = cardanEulerSingularityException40.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.String str45 = cardanEulerSingularityException18.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str45, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1676() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1676");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str31 = cardanEulerSingularityException13.getPattern();
java.lang.String str32 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException13.getSuppressed();
java.lang.Class<?> wildcardClass34 = throwableArray33.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Cardan angles singularity" + "'", str32, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(wildcardClass34);
}
@Test
public void test1677() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1677");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str18 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException16.getSuppressed();
java.lang.String str20 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException16.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Object[] objArray30 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException32.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Object[] objArray37 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException27.getSuppressed();
java.lang.String str39 = cardanEulerSingularityException27.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.String str43 = cardanEulerSingularityException41.getPattern();
java.lang.Object[] objArray44 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException46.getSuppressed();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException46.getSuppressed();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException46.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray53 = cardanEulerSingularityException52.getArguments();
java.lang.Object[] objArray54 = cardanEulerSingularityException52.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Object[] objArray63 = cardanEulerSingularityException41.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Object[] objArray66 = cardanEulerSingularityException16.getArguments();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
}
@Test
public void test1678() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1678");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.String str10 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray11 = cardanEulerSingularityException8.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
java.lang.String str16 = cardanEulerSingularityException13.getPattern();
java.lang.String str17 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str38 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
java.lang.String str43 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException40.getSuppressed();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException40.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray48 = cardanEulerSingularityException47.getArguments();
java.lang.Object[] objArray49 = cardanEulerSingularityException47.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
cardanEulerSingularityException47.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str54 = cardanEulerSingularityException47.getPattern();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str60 = cardanEulerSingularityException59.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str63 = cardanEulerSingularityException62.getPattern();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException62.getSuppressed();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str68 = cardanEulerSingularityException67.getPattern();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
java.lang.String str70 = cardanEulerSingularityException59.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
java.lang.Object[] objArray74 = cardanEulerSingularityException72.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException76 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray77 = cardanEulerSingularityException76.getArguments();
cardanEulerSingularityException72.addSuppressed((java.lang.Throwable) cardanEulerSingularityException76);
java.lang.Throwable[] throwableArray79 = cardanEulerSingularityException72.getSuppressed();
java.lang.String str80 = cardanEulerSingularityException72.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException82 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray83 = cardanEulerSingularityException82.getArguments();
java.lang.String str84 = cardanEulerSingularityException82.getPattern();
java.lang.Object[] objArray85 = cardanEulerSingularityException82.getArguments();
java.lang.Object[] objArray86 = cardanEulerSingularityException82.getArguments();
java.lang.String str87 = cardanEulerSingularityException82.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException89 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException82.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
cardanEulerSingularityException72.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
java.lang.Object[] objArray94 = cardanEulerSingularityException59.getArguments();
java.lang.String str95 = cardanEulerSingularityException59.getPattern();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Cardan angles singularity" + "'", str16, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Cardan angles singularity" + "'", str38, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Cardan angles singularity" + "'", str68, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(throwableArray79);
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "Euler angles singularity" + "'", str80, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray85);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray85), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray85), "[]");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray94);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray94), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray94), "[]");
org.junit.Assert.assertEquals("'" + str95 + "' != '" + "Euler angles singularity" + "'", str95, "Euler angles singularity");
}
@Test
public void test1679() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1679");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.Object[] objArray34 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException36.getSuppressed();
java.lang.String str39 = cardanEulerSingularityException36.getPattern();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException42.getSuppressed();
java.lang.String str50 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.String str52 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Object[] objArray54 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
}
@Test
public void test1680() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1680");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str18 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException16.getSuppressed();
java.lang.String str20 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException16.getSuppressed();
java.lang.Object[] objArray24 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.String str34 = cardanEulerSingularityException32.getPattern();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
}
@Test
public void test1681() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1681");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException1.getArguments();
java.lang.String str34 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray35 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
}
@Test
public void test1682() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1682");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray6 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray31 = cardanEulerSingularityException8.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray33 = cardanEulerSingularityException1.getArguments();
java.lang.Class<?> wildcardClass34 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(wildcardClass34);
}
@Test
public void test1683() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1683");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.String str25 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException28.getSuppressed();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException28.getSuppressed();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str45 = cardanEulerSingularityException28.getPattern();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException28.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException48.getSuppressed();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException48.getSuppressed();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException48.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException48.getPattern();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException48.getSuppressed();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Cardan angles singularity" + "'", str19, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Cardan angles singularity" + "'", str45, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertNotNull(throwableArray59);
}
@Test
public void test1684() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1684");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException17.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
java.lang.String str39 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray40 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException35.getSuppressed();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray42);
}
@Test
public void test1685() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1685");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException24.getSuppressed();
java.lang.String str32 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException36.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException36.getPattern();
java.lang.String str45 = cardanEulerSingularityException36.getPattern();
java.lang.String str46 = cardanEulerSingularityException36.getPattern();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException50.getArguments();
java.lang.String str53 = cardanEulerSingularityException50.getPattern();
java.lang.String str54 = cardanEulerSingularityException50.getPattern();
java.lang.String str55 = cardanEulerSingularityException50.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.String str63 = cardanEulerSingularityException61.getPattern();
java.lang.String str64 = cardanEulerSingularityException61.getPattern();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray70 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.String str75 = cardanEulerSingularityException68.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray78 = cardanEulerSingularityException77.getArguments();
java.lang.String str79 = cardanEulerSingularityException77.getPattern();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException77.getSuppressed();
java.lang.Object[] objArray82 = cardanEulerSingularityException77.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException85 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray86 = cardanEulerSingularityException85.getArguments();
java.lang.Object[] objArray87 = cardanEulerSingularityException85.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException89 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException91 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException89.addSuppressed((java.lang.Throwable) cardanEulerSingularityException91);
cardanEulerSingularityException85.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
java.lang.Throwable[] throwableArray94 = cardanEulerSingularityException85.getSuppressed();
cardanEulerSingularityException77.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Throwable[] throwableArray98 = cardanEulerSingularityException77.getSuppressed();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Cardan angles singularity" + "'", str53, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Cardan angles singularity" + "'", str54, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Euler angles singularity" + "'", str64, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Euler angles singularity" + "'", str75, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertEquals("'" + str79 + "' != '" + "Euler angles singularity" + "'", str79, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertNotNull(objArray87);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray87), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray87), "[]");
org.junit.Assert.assertNotNull(throwableArray94);
org.junit.Assert.assertNotNull(throwableArray98);
}
@Test
public void test1686() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1686");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str20 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.String str26 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException12.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str33 = cardanEulerSingularityException32.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str38 = cardanEulerSingularityException37.getPattern();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException37.getSuppressed();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
java.lang.Object[] objArray63 = cardanEulerSingularityException60.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException65 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray66 = cardanEulerSingularityException65.getArguments();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException65.getSuppressed();
java.lang.String str68 = cardanEulerSingularityException65.getPattern();
cardanEulerSingularityException60.addSuppressed((java.lang.Throwable) cardanEulerSingularityException65);
java.lang.Object[] objArray70 = cardanEulerSingularityException65.getArguments();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException65);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
}
@Test
public void test1687() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1687");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException17.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray28 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.String str30 = cardanEulerSingularityException3.getPattern();
java.lang.Class<?> wildcardClass31 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass31);
}
@Test
public void test1688() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1688");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException11.getPattern();
java.lang.String str18 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException11.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray22 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException11.getSuppressed();
java.lang.Class<?> wildcardClass25 = throwableArray24.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(wildcardClass25);
}
@Test
public void test1689() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1689");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException5.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException5.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray22 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str24 = cardanEulerSingularityException5.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str24, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1690() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1690");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException11.getPattern();
java.lang.String str18 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException11.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.String str25 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException23.getArguments();
java.lang.String str28 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray40 = cardanEulerSingularityException38.getArguments();
java.lang.String str41 = cardanEulerSingularityException38.getPattern();
java.lang.String str42 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray46 = cardanEulerSingularityException45.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException45.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException45.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str63 = cardanEulerSingularityException45.getPattern();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str66 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.String str70 = cardanEulerSingularityException68.getPattern();
java.lang.Object[] objArray71 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
java.lang.Object[] objArray75 = cardanEulerSingularityException73.getArguments();
java.lang.String str76 = cardanEulerSingularityException73.getPattern();
java.lang.String str77 = cardanEulerSingularityException73.getPattern();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Throwable[] throwableArray79 = cardanEulerSingularityException73.getSuppressed();
java.lang.Object[] objArray80 = cardanEulerSingularityException73.getArguments();
java.lang.String str81 = cardanEulerSingularityException73.getPattern();
java.lang.String str82 = cardanEulerSingularityException73.getPattern();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Cardan angles singularity" + "'", str42, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Cardan angles singularity" + "'", str63, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str66 + "' != '" + "Euler angles singularity" + "'", str66, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Cardan angles singularity" + "'", str76, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "Cardan angles singularity" + "'", str77, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray79);
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Cardan angles singularity" + "'", str81, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Cardan angles singularity" + "'", str82, "Cardan angles singularity");
}
@Test
public void test1691() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1691");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray32 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str37 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray39 = cardanEulerSingularityException34.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass42 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertNotNull(wildcardClass42);
}
@Test
public void test1692() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1692");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray29 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.String str32 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException38.getSuppressed();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException38.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException38.getPattern();
java.lang.String str56 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray59 = cardanEulerSingularityException58.getArguments();
java.lang.Object[] objArray60 = cardanEulerSingularityException58.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
java.lang.Object[] objArray65 = cardanEulerSingularityException62.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray68 = cardanEulerSingularityException67.getArguments();
java.lang.Throwable[] throwableArray69 = cardanEulerSingularityException67.getSuppressed();
java.lang.String str70 = cardanEulerSingularityException67.getPattern();
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
java.lang.Object[] objArray75 = cardanEulerSingularityException73.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray78 = cardanEulerSingularityException77.getArguments();
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException73.getSuppressed();
java.lang.String str81 = cardanEulerSingularityException73.getPattern();
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
java.lang.Throwable[] throwableArray85 = cardanEulerSingularityException62.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Cardan angles singularity" + "'", str12, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertNotNull(throwableArray69);
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray85);
}
@Test
public void test1693() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1693");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException24.getSuppressed();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException24.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray41 = cardanEulerSingularityException19.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
}
@Test
public void test1694() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1694");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray4 = cardanEulerSingularityException3.getArguments();
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException8.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray25 = cardanEulerSingularityException3.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str28 = cardanEulerSingularityException1.getPattern();
java.lang.String str29 = cardanEulerSingularityException1.getPattern();
java.lang.String str30 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Cardan angles singularity" + "'", str30, "Cardan angles singularity");
}
@Test
public void test1695() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1695");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray13 = cardanEulerSingularityException1.getArguments();
java.lang.String str14 = cardanEulerSingularityException1.getPattern();
java.lang.String str15 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
}
@Test
public void test1696() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1696");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
java.lang.String str11 = cardanEulerSingularityException1.getPattern();
java.lang.String str12 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
}
@Test
public void test1697() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1697");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Object[] objArray28 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray36 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException38.getSuppressed();
java.lang.String str41 = cardanEulerSingularityException38.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException38.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException44.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str49 = cardanEulerSingularityException48.getPattern();
java.lang.Object[] objArray50 = cardanEulerSingularityException48.getArguments();
java.lang.String str51 = cardanEulerSingularityException48.getPattern();
java.lang.String str52 = cardanEulerSingularityException48.getPattern();
java.lang.Object[] objArray53 = cardanEulerSingularityException48.getArguments();
cardanEulerSingularityException44.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
}
@Test
public void test1698() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1698");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str19 = cardanEulerSingularityException10.getPattern();
java.lang.String str20 = cardanEulerSingularityException10.getPattern();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException10.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.String str23 = cardanEulerSingularityException1.getPattern();
java.lang.Class<?> wildcardClass24 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Cardan angles singularity" + "'", str23, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass24);
}
@Test
public void test1699() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1699");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str33 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray35 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Object[] objArray42 = cardanEulerSingularityException40.getArguments();
java.lang.String str43 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.String str46 = cardanEulerSingularityException40.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str46, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1700() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1700");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.String str24 = cardanEulerSingularityException22.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException22.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException22.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray47 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException22.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
}
@Test
public void test1701() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1701");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str18 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
java.lang.String str20 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.String str22 = cardanEulerSingularityException17.getPattern();
java.lang.String str23 = cardanEulerSingularityException17.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException25.getSuppressed();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException25.getArguments();
java.lang.Throwable[] throwableArray30 = cardanEulerSingularityException25.getSuppressed();
java.lang.Object[] objArray31 = cardanEulerSingularityException25.getArguments();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException25.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.String str43 = cardanEulerSingularityException34.getPattern();
java.lang.String str44 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException17.getSuppressed();
java.lang.Object[] objArray49 = cardanEulerSingularityException17.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray30);
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
}
@Test
public void test1702() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1702");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Cardan angles singularity" + "'", str8, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
}
@Test
public void test1703() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1703");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Object[] objArray46 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray49 = cardanEulerSingularityException18.getArguments();
java.lang.Class<?> wildcardClass50 = objArray49.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(wildcardClass50);
}
@Test
public void test1704() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1704");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str15 = cardanEulerSingularityException14.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
java.lang.String str17 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str20 = cardanEulerSingularityException19.getPattern();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException19.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException40.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException40.getSuppressed();
java.lang.String str48 = cardanEulerSingularityException40.getPattern();
java.lang.String str49 = cardanEulerSingularityException40.getPattern();
java.lang.String str50 = cardanEulerSingularityException40.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray59 = cardanEulerSingularityException58.getArguments();
java.lang.Object[] objArray60 = cardanEulerSingularityException58.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray67 = cardanEulerSingularityException66.getArguments();
java.lang.Object[] objArray68 = cardanEulerSingularityException66.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException70.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException66.getSuppressed();
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException78 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray79 = cardanEulerSingularityException78.getArguments();
java.lang.Object[] objArray80 = cardanEulerSingularityException78.getArguments();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
java.lang.Throwable[] throwableArray82 = cardanEulerSingularityException78.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException84 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException86 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException84.addSuppressed((java.lang.Throwable) cardanEulerSingularityException86);
java.lang.String str88 = cardanEulerSingularityException86.getPattern();
java.lang.Throwable[] throwableArray89 = cardanEulerSingularityException86.getSuppressed();
java.lang.String str90 = cardanEulerSingularityException86.getPattern();
cardanEulerSingularityException78.addSuppressed((java.lang.Throwable) cardanEulerSingularityException86);
java.lang.Object[] objArray92 = cardanEulerSingularityException78.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
java.lang.Throwable[] throwableArray94 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Cardan angles singularity" + "'", str5, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(throwableArray82);
org.junit.Assert.assertEquals("'" + str88 + "' != '" + "Euler angles singularity" + "'", str88, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray89);
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Euler angles singularity" + "'", str90, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray92);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray92), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray92), "[]");
org.junit.Assert.assertNotNull(throwableArray94);
}
@Test
public void test1705() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1705");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException20.getSuppressed();
java.lang.String str29 = cardanEulerSingularityException20.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
}
@Test
public void test1706() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1706");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.String str23 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray32 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str37 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray39 = cardanEulerSingularityException29.getArguments();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException29.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.String str44 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray45 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException42.getArguments();
java.lang.String str47 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException49.getSuppressed();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException49.getSuppressed();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.String str55 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException29.getSuppressed();
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException29.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Cardan angles singularity" + "'", str22, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Cardan angles singularity" + "'", str23, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(throwableArray51);
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertNotNull(throwableArray60);
}
@Test
public void test1707() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1707");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.String str11 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray12 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException9.getArguments();
java.lang.String str14 = cardanEulerSingularityException9.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str19 = cardanEulerSingularityException3.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str19, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1708() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1708");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray10 = cardanEulerSingularityException3.getArguments();
java.lang.String str11 = cardanEulerSingularityException3.toString();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str11, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1709() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1709");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException17.getSuppressed();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray28 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray30 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray31 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException17.getArguments();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
}
@Test
public void test1710() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1710");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException12.getArguments();
java.lang.String str24 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
java.lang.String str31 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException43.getSuppressed();
java.lang.Object[] objArray47 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str49 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
java.lang.String str60 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.String str65 = cardanEulerSingularityException63.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException63.getArguments();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str72 = cardanEulerSingularityException63.getPattern();
java.lang.String str73 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException51.getSuppressed();
java.lang.String str76 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str78 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException12.getSuppressed();
java.lang.String str81 = cardanEulerSingularityException12.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Cardan angles singularity" + "'", str59, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str81, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1711() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1711");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException23.getSuppressed();
java.lang.Object[] objArray27 = cardanEulerSingularityException23.getArguments();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException23.getSuppressed();
java.lang.Object[] objArray29 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str36 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException34.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str40 = cardanEulerSingularityException39.getPattern();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
java.lang.String str42 = cardanEulerSingularityException39.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str45 = cardanEulerSingularityException44.getPattern();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException44.getSuppressed();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(throwableArray49);
}
@Test
public void test1712() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1712");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str25 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.String str27 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str30 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str35 = cardanEulerSingularityException34.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
java.lang.String str37 = cardanEulerSingularityException34.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str40 = cardanEulerSingularityException39.getPattern();
java.lang.Throwable[] throwableArray41 = cardanEulerSingularityException39.getSuppressed();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str44 = cardanEulerSingularityException24.getPattern();
java.lang.String str45 = cardanEulerSingularityException24.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray48 = cardanEulerSingularityException47.getArguments();
java.lang.String str49 = cardanEulerSingularityException47.getPattern();
java.lang.Object[] objArray50 = cardanEulerSingularityException47.getArguments();
java.lang.Object[] objArray51 = cardanEulerSingularityException47.getArguments();
java.lang.String str52 = cardanEulerSingularityException47.getPattern();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
java.lang.String str61 = cardanEulerSingularityException59.getPattern();
java.lang.Object[] objArray62 = cardanEulerSingularityException59.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException59.getArguments();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException59.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray67 = cardanEulerSingularityException66.getArguments();
java.lang.Object[] objArray68 = cardanEulerSingularityException66.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str71 = cardanEulerSingularityException70.getPattern();
java.lang.Object[] objArray72 = cardanEulerSingularityException70.getArguments();
java.lang.String str73 = cardanEulerSingularityException70.getPattern();
java.lang.String str74 = cardanEulerSingularityException70.getPattern();
java.lang.Object[] objArray75 = cardanEulerSingularityException70.getArguments();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str77 = cardanEulerSingularityException66.getPattern();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str37 + "' != '" + "Euler angles singularity" + "'", str37, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray41);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "Euler angles singularity" + "'", str52, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertEquals("'" + str71 + "' != '" + "Euler angles singularity" + "'", str71, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str74 + "' != '" + "Euler angles singularity" + "'", str74, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "Euler angles singularity" + "'", str77, "Euler angles singularity");
}
@Test
public void test1713() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1713");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Object[] objArray34 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.String str39 = cardanEulerSingularityException37.getPattern();
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.String str46 = cardanEulerSingularityException37.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Object[] objArray50 = cardanEulerSingularityException48.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.String str57 = cardanEulerSingularityException48.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.String str60 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str60, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1714() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1714");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str16 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException27.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Object[] objArray32 = cardanEulerSingularityException22.getArguments();
java.lang.String str33 = cardanEulerSingularityException22.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.String str36 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException5.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str38, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1715() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1715");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray16 = cardanEulerSingularityException15.getArguments();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str19 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.String str23 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException21.getArguments();
java.lang.String str26 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str41 = cardanEulerSingularityException33.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
java.lang.String str45 = cardanEulerSingularityException43.getPattern();
java.lang.Object[] objArray46 = cardanEulerSingularityException43.getArguments();
java.lang.Object[] objArray47 = cardanEulerSingularityException43.getArguments();
java.lang.String str48 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Object[] objArray53 = cardanEulerSingularityException50.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.String str55 = cardanEulerSingularityException28.getPattern();
java.lang.String str56 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.String str63 = cardanEulerSingularityException61.getPattern();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException61.getSuppressed();
java.lang.String str65 = cardanEulerSingularityException61.getPattern();
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException61.getSuppressed();
java.lang.String str67 = cardanEulerSingularityException61.getPattern();
java.lang.String str68 = cardanEulerSingularityException61.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray71 = cardanEulerSingularityException70.getArguments();
java.lang.Object[] objArray72 = cardanEulerSingularityException70.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException74 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray75 = cardanEulerSingularityException74.getArguments();
cardanEulerSingularityException70.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
java.lang.Object[] objArray77 = cardanEulerSingularityException74.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException79 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray80 = cardanEulerSingularityException79.getArguments();
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException79.getSuppressed();
java.lang.String str82 = cardanEulerSingularityException79.getPattern();
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
java.lang.Object[] objArray84 = cardanEulerSingularityException74.getArguments();
java.lang.Throwable[] throwableArray85 = cardanEulerSingularityException74.getSuppressed();
java.lang.Object[] objArray86 = cardanEulerSingularityException74.getArguments();
cardanEulerSingularityException61.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
java.lang.String str88 = cardanEulerSingularityException61.getPattern();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Euler angles singularity" + "'", str67, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Euler angles singularity" + "'", str82, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertNotNull(throwableArray85);
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertEquals("'" + str88 + "' != '" + "Euler angles singularity" + "'", str88, "Euler angles singularity");
}
@Test
public void test1716() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1716");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException11.getPattern();
java.lang.String str18 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException11.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str23 = cardanEulerSingularityException3.getPattern();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
}
@Test
public void test1717() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1717");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException21.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str31 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray35 = cardanEulerSingularityException29.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
}
@Test
public void test1718() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1718");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Class<?> wildcardClass21 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass21);
}
@Test
public void test1719() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1719");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str27 = cardanEulerSingularityException1.getPattern();
java.lang.String str28 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.String str32 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.String str39 = cardanEulerSingularityException30.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str50 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException30.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException30.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.String str57 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str57, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1720() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1720");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException21.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Object[] objArray25 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException21.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
}
@Test
public void test1721() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1721");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray29 = cardanEulerSingularityException7.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray35 = cardanEulerSingularityException34.getArguments();
java.lang.Object[] objArray36 = cardanEulerSingularityException34.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Object[] objArray41 = cardanEulerSingularityException38.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException43.getSuppressed();
java.lang.String str46 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray50 = cardanEulerSingularityException49.getArguments();
java.lang.Object[] objArray51 = cardanEulerSingularityException49.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray54 = cardanEulerSingularityException53.getArguments();
cardanEulerSingularityException49.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException49.getSuppressed();
java.lang.String str57 = cardanEulerSingularityException49.getPattern();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.String str59 = cardanEulerSingularityException49.getPattern();
java.lang.String str60 = cardanEulerSingularityException49.getPattern();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException49.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Cardan angles singularity" + "'", str2, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Cardan angles singularity" + "'", str3, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray61);
}
@Test
public void test1722() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1722");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str10 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str14 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str16 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Object[] objArray34 = cardanEulerSingularityException18.getArguments();
java.lang.String str35 = cardanEulerSingularityException18.getPattern();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray36);
}
@Test
public void test1723() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1723");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.String str15 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
}
@Test
public void test1724() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1724");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException5.getArguments();
java.lang.String str17 = cardanEulerSingularityException5.getPattern();
java.lang.String str18 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
}
@Test
public void test1725() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1725");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.String str11 = cardanEulerSingularityException9.getPattern();
java.lang.Object[] objArray12 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
java.lang.String str17 = cardanEulerSingularityException14.getPattern();
java.lang.String str18 = cardanEulerSingularityException14.getPattern();
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException21.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException21.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException21.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException21.getSuppressed();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.String str39 = cardanEulerSingularityException14.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Cardan angles singularity" + "'", str17, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Cardan angles singularity" + "'", str39, "Cardan angles singularity");
}
@Test
public void test1726() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1726");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException12.getArguments();
java.lang.String str24 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
java.lang.String str31 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException43.getSuppressed();
java.lang.Object[] objArray47 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str49 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
java.lang.String str60 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.String str65 = cardanEulerSingularityException63.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException63.getArguments();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str72 = cardanEulerSingularityException63.getPattern();
java.lang.String str73 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException51.getSuppressed();
java.lang.String str76 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str78 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str80 = cardanEulerSingularityException12.getPattern();
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException12.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Cardan angles singularity" + "'", str59, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "Euler angles singularity" + "'", str80, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray81);
}
@Test
public void test1727() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1727");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass7 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(wildcardClass7);
}
@Test
public void test1728() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1728");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray10 = cardanEulerSingularityException9.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException9.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException9.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException9);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException5.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str22 = cardanEulerSingularityException5.getPattern();
java.lang.String str23 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray27 = cardanEulerSingularityException5.getArguments();
java.lang.String str28 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException5.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
}
@Test
public void test1729() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1729");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.String str14 = cardanEulerSingularityException12.getPattern();
java.lang.String str15 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str26 = cardanEulerSingularityException19.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
java.lang.String str30 = cardanEulerSingularityException28.getPattern();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str35 = cardanEulerSingularityException28.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Cardan angles singularity" + "'", str5, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Cardan angles singularity" + "'", str6, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str35, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1730() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1730");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
java.lang.String str27 = cardanEulerSingularityException24.getPattern();
java.lang.String str28 = cardanEulerSingularityException24.getPattern();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException31.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.Object[] objArray39 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException24.getSuppressed();
java.lang.Object[] objArray51 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.String str59 = cardanEulerSingularityException57.getPattern();
java.lang.String str60 = cardanEulerSingularityException57.getPattern();
cardanEulerSingularityException53.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Object[] objArray62 = cardanEulerSingularityException57.getArguments();
java.lang.Object[] objArray63 = cardanEulerSingularityException57.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException57.getSuppressed();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Cardan angles singularity" + "'", str27, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray65);
}
@Test
public void test1731() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1731");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.String str12 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.String str14 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray17 = cardanEulerSingularityException1.getArguments();
java.lang.String str18 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str18, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1732() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1732");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray49 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException6.getSuppressed();
java.lang.Class<?> wildcardClass51 = throwableArray50.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertNotNull(wildcardClass51);
}
@Test
public void test1733() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1733");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
}
@Test
public void test1734() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1734");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str17 = cardanEulerSingularityException10.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException27.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.String str38 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.String str41 = cardanEulerSingularityException10.toString();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Cardan angles singularity" + "'", str8, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str41, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1735() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1735");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Cardan angles singularity" + "'", str18, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
}
@Test
public void test1736() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1736");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException13.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException13.getPattern();
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray26 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException13.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
}
@Test
public void test1737() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1737");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException11.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str18, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1738() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1738");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException12.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException12.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray29 = cardanEulerSingularityException7.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.String str32 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Cardan angles singularity" + "'", str2, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Cardan angles singularity" + "'", str3, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Cardan angles singularity" + "'", str32, "Cardan angles singularity");
}
@Test
public void test1739() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1739");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Object[] objArray19 = cardanEulerSingularityException14.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str44 = cardanEulerSingularityException43.getPattern();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException43.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException50.getSuppressed();
java.lang.Object[] objArray53 = cardanEulerSingularityException50.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.String str59 = cardanEulerSingularityException57.getPattern();
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException57.getSuppressed();
java.lang.String str61 = cardanEulerSingularityException57.getPattern();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException57.getSuppressed();
java.lang.String str63 = cardanEulerSingularityException57.getPattern();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException50.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.Object[] objArray67 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray65);
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
}
@Test
public void test1740() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1740");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str16 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException27.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException27.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Object[] objArray32 = cardanEulerSingularityException22.getArguments();
java.lang.String str33 = cardanEulerSingularityException22.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException22.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray36 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException5.getSuppressed();
java.lang.Class<?> wildcardClass38 = cardanEulerSingularityException5.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(wildcardClass38);
}
@Test
public void test1741() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1741");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException12.getArguments();
java.lang.String str24 = cardanEulerSingularityException12.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray30 = cardanEulerSingularityException26.getArguments();
java.lang.String str31 = cardanEulerSingularityException26.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray40 = cardanEulerSingularityException39.getArguments();
java.lang.Object[] objArray41 = cardanEulerSingularityException39.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray44 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException43.getSuppressed();
java.lang.Object[] objArray47 = cardanEulerSingularityException43.getArguments();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str49 = cardanEulerSingularityException43.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
java.lang.String str60 = cardanEulerSingularityException56.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.String str65 = cardanEulerSingularityException63.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray67 = cardanEulerSingularityException63.getArguments();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.String str72 = cardanEulerSingularityException63.getPattern();
java.lang.String str73 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.Throwable[] throwableArray75 = cardanEulerSingularityException51.getSuppressed();
java.lang.String str76 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str78 = cardanEulerSingularityException43.getPattern();
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.Object[] objArray80 = cardanEulerSingularityException43.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Cardan angles singularity" + "'", str59, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Cardan angles singularity" + "'", str60, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "Euler angles singularity" + "'", str73, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray75);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str78 + "' != '" + "Euler angles singularity" + "'", str78, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
}
@Test
public void test1742() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1742");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray12 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str14 = cardanEulerSingularityException6.getPattern();
java.lang.String str15 = cardanEulerSingularityException6.getPattern();
java.lang.Class<?> wildcardClass16 = cardanEulerSingularityException6.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Cardan angles singularity" + "'", str14, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Cardan angles singularity" + "'", str15, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass16);
}
@Test
public void test1743() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1743");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str49 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException6.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray52 = cardanEulerSingularityException6.getArguments();
java.lang.String str53 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray57 = cardanEulerSingularityException56.getArguments();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str61 = cardanEulerSingularityException60.getPattern();
java.lang.Object[] objArray62 = cardanEulerSingularityException60.getArguments();
java.lang.String str63 = cardanEulerSingularityException60.getPattern();
java.lang.String str64 = cardanEulerSingularityException60.getPattern();
java.lang.Object[] objArray65 = cardanEulerSingularityException60.getArguments();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray70 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.String str75 = cardanEulerSingularityException72.getPattern();
java.lang.Object[] objArray76 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException60.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Cardan angles singularity" + "'", str49, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Cardan angles singularity" + "'", str51, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Cardan angles singularity" + "'", str53, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Euler angles singularity" + "'", str64, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Euler angles singularity" + "'", str75, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
}
@Test
public void test1744() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1744");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException33.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.String str40 = cardanEulerSingularityException33.getPattern();
java.lang.String str41 = cardanEulerSingularityException33.getPattern();
java.lang.String str42 = cardanEulerSingularityException33.toString();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str42, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1745() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1745");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Object[] objArray32 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.String str38 = cardanEulerSingularityException36.getPattern();
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray40 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.String str44 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray45 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray46 = cardanEulerSingularityException42.getArguments();
java.lang.String str47 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException49 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException49);
java.lang.Class<?> wildcardClass53 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass53);
}
@Test
public void test1746() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1746");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray49 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray55 = cardanEulerSingularityException51.getArguments();
java.lang.String str56 = cardanEulerSingularityException51.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray59 = cardanEulerSingularityException58.getArguments();
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException58.getSuppressed();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException58.getSuppressed();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
java.lang.Object[] objArray63 = cardanEulerSingularityException51.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str65 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray66 = cardanEulerSingularityException51.getArguments();
java.lang.String str67 = cardanEulerSingularityException51.getPattern();
java.lang.String str68 = cardanEulerSingularityException51.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertEquals("'" + str65 + "' != '" + "Euler angles singularity" + "'", str65, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray66);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray66), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray66), "[]");
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Euler angles singularity" + "'", str67, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
}
@Test
public void test1747() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1747");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str10 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException8.getPattern();
java.lang.Throwable[] throwableArray13 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str14 = cardanEulerSingularityException8.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.String str16 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.String str20 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray21 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.String str27 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray30 = cardanEulerSingularityException29.getArguments();
java.lang.Object[] objArray31 = cardanEulerSingularityException29.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException29.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.String str38 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Object[] objArray40 = cardanEulerSingularityException18.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str53 = cardanEulerSingularityException52.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException52.getArguments();
java.lang.String str55 = cardanEulerSingularityException52.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str58 = cardanEulerSingularityException57.getPattern();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException57.getSuppressed();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Object[] objArray62 = cardanEulerSingularityException52.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException18.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str67 = cardanEulerSingularityException66.getPattern();
java.lang.String str68 = cardanEulerSingularityException66.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
java.lang.Object[] objArray70 = cardanEulerSingularityException66.getArguments();
java.lang.Throwable[] throwableArray71 = cardanEulerSingularityException66.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException75 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException75.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.String str79 = cardanEulerSingularityException77.getPattern();
java.lang.String str80 = cardanEulerSingularityException77.getPattern();
cardanEulerSingularityException73.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException84 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str85 = cardanEulerSingularityException84.getPattern();
java.lang.Object[] objArray86 = cardanEulerSingularityException84.getArguments();
java.lang.String str87 = cardanEulerSingularityException84.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException89 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str90 = cardanEulerSingularityException89.getPattern();
java.lang.Throwable[] throwableArray91 = cardanEulerSingularityException89.getSuppressed();
cardanEulerSingularityException84.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
java.lang.Object[] objArray93 = cardanEulerSingularityException89.getArguments();
java.lang.Throwable[] throwableArray94 = cardanEulerSingularityException89.getSuppressed();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
java.lang.String str97 = cardanEulerSingularityException66.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray59);
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Cardan angles singularity" + "'", str67, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Cardan angles singularity" + "'", str68, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(throwableArray71);
org.junit.Assert.assertEquals("'" + str79 + "' != '" + "Euler angles singularity" + "'", str79, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "Euler angles singularity" + "'", str80, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Euler angles singularity" + "'", str85, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertEquals("'" + str87 + "' != '" + "Euler angles singularity" + "'", str87, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Euler angles singularity" + "'", str90, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray91);
org.junit.Assert.assertNotNull(objArray93);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray93), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray93), "[]");
org.junit.Assert.assertNotNull(throwableArray94);
org.junit.Assert.assertEquals("'" + str97 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str97, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1748() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1748");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str7 = cardanEulerSingularityException5.getPattern();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str16 = cardanEulerSingularityException14.getPattern();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException14.getSuppressed();
java.lang.String str18 = cardanEulerSingularityException14.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException14.getSuppressed();
java.lang.String str20 = cardanEulerSingularityException14.getPattern();
java.lang.String str21 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
java.lang.Object[] objArray30 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException32.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Object[] objArray37 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException27.getSuppressed();
java.lang.Object[] objArray39 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.String str42 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Cardan angles singularity" + "'", str42, "Cardan angles singularity");
}
@Test
public void test1749() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1749");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.String str8 = cardanEulerSingularityException3.getPattern();
java.lang.String str9 = cardanEulerSingularityException3.getPattern();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
}
@Test
public void test1750() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1750");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str31 = cardanEulerSingularityException6.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException33.getSuppressed();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException33.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException40.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray45 = cardanEulerSingularityException44.getArguments();
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.String str47 = cardanEulerSingularityException40.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.String str50 = cardanEulerSingularityException6.getPattern();
java.lang.String str51 = cardanEulerSingularityException6.getPattern();
java.lang.Object[] objArray52 = cardanEulerSingularityException6.getArguments();
java.lang.Class<?> wildcardClass53 = objArray52.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Cardan angles singularity" + "'", str50, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Cardan angles singularity" + "'", str51, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(wildcardClass53);
}
@Test
public void test1751() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1751");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray26 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
}
@Test
public void test1752() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1752");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray6 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
}
@Test
public void test1753() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1753");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str21 = cardanEulerSingularityException14.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.String str25 = cardanEulerSingularityException23.getPattern();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
}
@Test
public void test1754() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1754");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
java.lang.String str7 = cardanEulerSingularityException3.getPattern();
java.lang.String str8 = cardanEulerSingularityException3.getPattern();
java.lang.Class<?> wildcardClass9 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass9);
}
@Test
public void test1755() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1755");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Object[] objArray23 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException25.getArguments();
java.lang.String str28 = cardanEulerSingularityException25.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
java.lang.String str38 = cardanEulerSingularityException35.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str41 = cardanEulerSingularityException40.getPattern();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray45 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str49 = cardanEulerSingularityException48.getPattern();
java.lang.Object[] objArray50 = cardanEulerSingularityException48.getArguments();
java.lang.String str51 = cardanEulerSingularityException48.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str54 = cardanEulerSingularityException53.getPattern();
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException53.getSuppressed();
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.String str57 = cardanEulerSingularityException48.getPattern();
java.lang.String str58 = cardanEulerSingularityException48.getPattern();
java.lang.Throwable[] throwableArray59 = cardanEulerSingularityException48.getSuppressed();
java.lang.String str60 = cardanEulerSingularityException48.getPattern();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException48.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray59);
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertNotNull(throwableArray63);
}
@Test
public void test1756() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1756");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str18 = cardanEulerSingularityException17.getPattern();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
java.lang.String str20 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray22 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException5.getArguments();
java.lang.String str24 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException5.getPattern();
java.lang.String str27 = cardanEulerSingularityException5.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Euler angles singularity" + "'", str20, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str27, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1757() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1757");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.String str25 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str27 = cardanEulerSingularityException1.getPattern();
java.lang.String str28 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.String str32 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
java.lang.Object[] objArray37 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.String str39 = cardanEulerSingularityException30.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str50 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.Throwable[] throwableArray52 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException30.getSuppressed();
java.lang.String str55 = cardanEulerSingularityException30.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.String str57 = cardanEulerSingularityException30.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray52);
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Euler angles singularity" + "'", str55, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str57, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1758() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1758");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Object[] objArray34 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
java.lang.String str39 = cardanEulerSingularityException37.getPattern();
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.String str46 = cardanEulerSingularityException37.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.Object[] objArray50 = cardanEulerSingularityException48.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.String str57 = cardanEulerSingularityException48.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Object[] objArray60 = cardanEulerSingularityException48.getArguments();
java.lang.Class<?> wildcardClass61 = objArray60.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(wildcardClass61);
}
@Test
public void test1759() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1759");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.String str7 = cardanEulerSingularityException1.getPattern();
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray9 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str22 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
java.lang.String str24 = cardanEulerSingularityException21.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str27 = cardanEulerSingularityException26.getPattern();
java.lang.Throwable[] throwableArray28 = cardanEulerSingularityException26.getSuppressed();
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.Object[] objArray34 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass37 = throwableArray36.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray28);
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(wildcardClass37);
}
@Test
public void test1760() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1760");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.String str5 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray7 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException1.getSuppressed();
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Cardan angles singularity" + "'", str5, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
}
@Test
public void test1761() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1761");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException5.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException5.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException19.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException19.getSuppressed();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException19.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException19.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException19.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException27.getSuppressed();
java.lang.Object[] objArray30 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str36 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str38 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException34.getSuppressed();
java.lang.String str40 = cardanEulerSingularityException34.getPattern();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.String str42 = cardanEulerSingularityException34.getPattern();
java.lang.String str43 = cardanEulerSingularityException34.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException34.getSuppressed();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Euler angles singularity" + "'", str42, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
}
@Test
public void test1762() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1762");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.Object[] objArray28 = cardanEulerSingularityException26.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str33 = cardanEulerSingularityException32.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException32.getArguments();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str38 = cardanEulerSingularityException37.getPattern();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException37.getSuppressed();
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str43 = cardanEulerSingularityException42.getPattern();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException47 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str48 = cardanEulerSingularityException47.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException47.getSuppressed();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException47);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException32.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.String str55 = cardanEulerSingularityException53.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str59 = cardanEulerSingularityException58.getPattern();
java.lang.Object[] objArray60 = cardanEulerSingularityException58.getArguments();
java.lang.String str61 = cardanEulerSingularityException58.getPattern();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException58.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException64 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray65 = cardanEulerSingularityException64.getArguments();
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray68 = cardanEulerSingularityException64.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException70 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray71 = cardanEulerSingularityException70.getArguments();
java.lang.Object[] objArray72 = cardanEulerSingularityException70.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException74 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException76 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException76);
cardanEulerSingularityException70.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
cardanEulerSingularityException64.addSuppressed((java.lang.Throwable) cardanEulerSingularityException70);
java.lang.Throwable[] throwableArray80 = cardanEulerSingularityException64.getSuppressed();
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException64.getSuppressed();
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException64);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
java.lang.String str84 = cardanEulerSingularityException1.getPattern();
java.lang.String str85 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray86 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertNotNull(throwableArray68);
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(throwableArray80);
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Cardan angles singularity" + "'", str84, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str85 + "' != '" + "Cardan angles singularity" + "'", str85, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray86);
}
@Test
public void test1763() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1763");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str12 = cardanEulerSingularityException1.getPattern();
java.lang.String str13 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
}
@Test
public void test1764() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1764");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray7 = cardanEulerSingularityException5.getArguments();
java.lang.String str8 = cardanEulerSingularityException5.getPattern();
java.lang.String str9 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str12 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
}
@Test
public void test1765() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1765");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException9 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException9.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str15 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str17 = cardanEulerSingularityException11.getPattern();
java.lang.String str18 = cardanEulerSingularityException11.getPattern();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException11.getSuppressed();
java.lang.Object[] objArray20 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.String str25 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException23.getArguments();
java.lang.String str28 = cardanEulerSingularityException23.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.String str35 = cardanEulerSingularityException33.getPattern();
java.lang.Object[] objArray36 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray40 = cardanEulerSingularityException38.getArguments();
java.lang.String str41 = cardanEulerSingularityException38.getPattern();
java.lang.String str42 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray46 = cardanEulerSingularityException45.getArguments();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException45.getSuppressed();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException45.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException57);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException45.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str63 = cardanEulerSingularityException45.getPattern();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
java.lang.Throwable[] throwableArray66 = cardanEulerSingularityException23.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.String str70 = cardanEulerSingularityException68.getPattern();
java.lang.Object[] objArray71 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException73 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray74 = cardanEulerSingularityException73.getArguments();
java.lang.Object[] objArray75 = cardanEulerSingularityException73.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.Object[] objArray77 = cardanEulerSingularityException73.getArguments();
java.lang.Throwable[] throwableArray78 = cardanEulerSingularityException73.getSuppressed();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException73);
java.lang.String str80 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException23.getSuppressed();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Cardan angles singularity" + "'", str41, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "Cardan angles singularity" + "'", str42, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray46);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray46), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray46), "[]");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Cardan angles singularity" + "'", str63, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray66);
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray71);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray71), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray71), "[]");
org.junit.Assert.assertNotNull(objArray74);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray74), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray74), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertNotNull(objArray77);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray77), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray77), "[]");
org.junit.Assert.assertNotNull(throwableArray78);
org.junit.Assert.assertEquals("'" + str80 + "' != '" + "Euler angles singularity" + "'", str80, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray81);
}
@Test
public void test1766() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1766");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException5.getSuppressed();
java.lang.String str30 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException32 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray33 = cardanEulerSingularityException32.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException32.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException32.getPattern();
java.lang.String str36 = cardanEulerSingularityException32.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException32);
java.lang.String str38 = cardanEulerSingularityException32.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "Euler angles singularity" + "'", str30, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Cardan angles singularity" + "'", str36, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Cardan angles singularity" + "'", str38, "Cardan angles singularity");
}
@Test
public void test1767() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1767");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str6 = cardanEulerSingularityException5.getPattern();
java.lang.Throwable[] throwableArray7 = cardanEulerSingularityException5.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.String str23 = cardanEulerSingularityException21.getPattern();
java.lang.Object[] objArray24 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.String str27 = cardanEulerSingularityException15.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException34 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException34.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException34);
java.lang.Object[] objArray39 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException30.getSuppressed();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray7);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Cardan angles singularity" + "'", str27, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(throwableArray42);
}
@Test
public void test1768() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1768");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.String str16 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str29 = cardanEulerSingularityException28.getPattern();
java.lang.Object[] objArray30 = cardanEulerSingularityException28.getArguments();
java.lang.String str31 = cardanEulerSingularityException28.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str34 = cardanEulerSingularityException33.getPattern();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException39);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
java.lang.Object[] objArray49 = cardanEulerSingularityException46.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException51.getSuppressed();
java.lang.String str54 = cardanEulerSingularityException51.getPattern();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.Object[] objArray56 = cardanEulerSingularityException51.getArguments();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException60 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray61 = cardanEulerSingularityException60.getArguments();
java.lang.Throwable[] throwableArray62 = cardanEulerSingularityException60.getSuppressed();
java.lang.String str63 = cardanEulerSingularityException60.getPattern();
java.lang.Throwable[] throwableArray64 = cardanEulerSingularityException60.getSuppressed();
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException60.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException60);
java.lang.Object[] objArray67 = cardanEulerSingularityException60.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Euler angles singularity" + "'", str29, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray30);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray30), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray30), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Euler angles singularity" + "'", str54, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(objArray61);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray61), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray61), "[]");
org.junit.Assert.assertNotNull(throwableArray62);
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray64);
org.junit.Assert.assertNotNull(throwableArray65);
org.junit.Assert.assertNotNull(objArray67);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray67), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray67), "[]");
}
@Test
public void test1769() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1769");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
java.lang.String str7 = cardanEulerSingularityException1.toString();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Cardan angles singularity" + "'", str2, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Cardan angles singularity" + "'", str3, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Cardan angles singularity" + "'", str4, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Cardan angles singularity" + "'", str6, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity" + "'", str7, "org.apache.commons.math.geometry.CardanEulerSingularityException: Cardan angles singularity");
}
@Test
public void test1770() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1770");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.String str21 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException24.getSuppressed();
java.lang.String str32 = cardanEulerSingularityException24.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray34 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Throwable[] throwableArray43 = cardanEulerSingularityException36.getSuppressed();
java.lang.String str44 = cardanEulerSingularityException36.getPattern();
java.lang.String str45 = cardanEulerSingularityException36.getPattern();
java.lang.String str46 = cardanEulerSingularityException36.getPattern();
java.lang.Throwable[] throwableArray47 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException50.getArguments();
java.lang.String str53 = cardanEulerSingularityException50.getPattern();
java.lang.String str54 = cardanEulerSingularityException50.getPattern();
java.lang.String str55 = cardanEulerSingularityException50.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException57 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
java.lang.String str63 = cardanEulerSingularityException61.getPattern();
java.lang.String str64 = cardanEulerSingularityException61.getPattern();
cardanEulerSingularityException57.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException68 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray69 = cardanEulerSingularityException68.getArguments();
java.lang.Object[] objArray70 = cardanEulerSingularityException68.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException72 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray73 = cardanEulerSingularityException72.getArguments();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException72);
java.lang.String str75 = cardanEulerSingularityException68.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray78 = cardanEulerSingularityException77.getArguments();
java.lang.String str79 = cardanEulerSingularityException77.getPattern();
cardanEulerSingularityException68.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException77.getSuppressed();
java.lang.Object[] objArray82 = cardanEulerSingularityException77.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException85 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray86 = cardanEulerSingularityException85.getArguments();
java.lang.Object[] objArray87 = cardanEulerSingularityException85.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException89 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException91 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException89.addSuppressed((java.lang.Throwable) cardanEulerSingularityException91);
cardanEulerSingularityException85.addSuppressed((java.lang.Throwable) cardanEulerSingularityException89);
java.lang.Throwable[] throwableArray94 = cardanEulerSingularityException85.getSuppressed();
cardanEulerSingularityException77.addSuppressed((java.lang.Throwable) cardanEulerSingularityException85);
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException77);
java.lang.Object[] objArray98 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray99 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Euler angles singularity" + "'", str32, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str46 + "' != '" + "Euler angles singularity" + "'", str46, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray47);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Cardan angles singularity" + "'", str53, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "Cardan angles singularity" + "'", str54, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str55 + "' != '" + "Cardan angles singularity" + "'", str55, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str63 + "' != '" + "Euler angles singularity" + "'", str63, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "Euler angles singularity" + "'", str64, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray69);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray69), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray69), "[]");
org.junit.Assert.assertNotNull(objArray70);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray70), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray70), "[]");
org.junit.Assert.assertNotNull(objArray73);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray73), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray73), "[]");
org.junit.Assert.assertEquals("'" + str75 + "' != '" + "Euler angles singularity" + "'", str75, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertEquals("'" + str79 + "' != '" + "Euler angles singularity" + "'", str79, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray86);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray86), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray86), "[]");
org.junit.Assert.assertNotNull(objArray87);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray87), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray87), "[]");
org.junit.Assert.assertNotNull(throwableArray94);
org.junit.Assert.assertNotNull(objArray98);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray98), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray98), "[]");
org.junit.Assert.assertNotNull(objArray99);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray99), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray99), "[]");
}
@Test
public void test1771() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1771");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
java.lang.String str16 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray17 = cardanEulerSingularityException5.getArguments();
java.lang.String str18 = cardanEulerSingularityException5.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str21 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
java.lang.String str23 = cardanEulerSingularityException20.getPattern();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException20.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException20.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray27 = cardanEulerSingularityException20.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
}
@Test
public void test1772() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1772");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.String str10 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str21 = cardanEulerSingularityException12.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str26 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray27);
}
@Test
public void test1773() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1773");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.String str12 = cardanEulerSingularityException10.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray16 = cardanEulerSingularityException15.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException15.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException15.getSuppressed();
java.lang.Throwable[] throwableArray19 = cardanEulerSingularityException15.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
java.lang.Object[] objArray23 = cardanEulerSingularityException21.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
cardanEulerSingularityException21.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Object[] objArray35 = cardanEulerSingularityException33.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray38 = cardanEulerSingularityException37.getArguments();
cardanEulerSingularityException33.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Object[] objArray40 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException42.getSuppressed();
java.lang.String str45 = cardanEulerSingularityException42.getPattern();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
java.lang.Object[] objArray47 = cardanEulerSingularityException37.getArguments();
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException37.getSuppressed();
java.lang.Object[] objArray49 = cardanEulerSingularityException37.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException53 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException53);
java.lang.Throwable[] throwableArray55 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException37.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException15.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
java.lang.Object[] objArray58 = cardanEulerSingularityException15.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.String str60 = cardanEulerSingularityException1.getPattern();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException1.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(throwableArray19);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(throwableArray55);
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray61);
}
@Test
public void test1774() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1774");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Object[] objArray6 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray7 = cardanEulerSingularityException3.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException3.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray10 = cardanEulerSingularityException3.getArguments();
java.lang.Object[] objArray11 = cardanEulerSingularityException3.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
java.lang.String str22 = cardanEulerSingularityException18.getPattern();
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray25 = cardanEulerSingularityException18.getArguments();
java.lang.String str26 = cardanEulerSingularityException18.getPattern();
java.lang.String str27 = cardanEulerSingularityException18.getPattern();
java.lang.String str28 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
java.lang.String str34 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException30.getSuppressed();
java.lang.Object[] objArray36 = cardanEulerSingularityException30.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str39 = cardanEulerSingularityException38.getPattern();
java.lang.Object[] objArray40 = cardanEulerSingularityException38.getArguments();
java.lang.String str41 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str44 = cardanEulerSingularityException43.getPattern();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException43.getSuppressed();
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
java.lang.String str47 = cardanEulerSingularityException38.getPattern();
java.lang.String str48 = cardanEulerSingularityException38.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException38.getSuppressed();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray51 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Cardan angles singularity" + "'", str21, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Cardan angles singularity" + "'", str22, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Cardan angles singularity" + "'", str26, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Cardan angles singularity" + "'", str27, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Cardan angles singularity" + "'", str28, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Cardan angles singularity" + "'", str33, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "Euler angles singularity" + "'", str41, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(throwableArray51);
}
@Test
public void test1775() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1775");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.String str33 = cardanEulerSingularityException17.getPattern();
java.lang.String str34 = cardanEulerSingularityException17.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
}
@Test
public void test1776() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1776");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException16.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray23 = cardanEulerSingularityException22.getArguments();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException22.getSuppressed();
java.lang.Object[] objArray25 = cardanEulerSingularityException22.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.String str31 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str33 = cardanEulerSingularityException29.getPattern();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException29.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException29.getPattern();
cardanEulerSingularityException22.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException29.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException43.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException45.getPattern();
java.lang.String str48 = cardanEulerSingularityException45.getPattern();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.Object[] objArray50 = cardanEulerSingularityException45.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException52 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Throwable[] throwableArray56 = cardanEulerSingularityException52.getSuppressed();
java.lang.Throwable[] throwableArray57 = cardanEulerSingularityException52.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str60 = cardanEulerSingularityException59.getPattern();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException63.getSuppressed();
java.lang.String str66 = cardanEulerSingularityException63.getPattern();
java.lang.Throwable[] throwableArray67 = cardanEulerSingularityException63.getSuppressed();
java.lang.String str68 = cardanEulerSingularityException63.getPattern();
java.lang.Throwable[] throwableArray69 = cardanEulerSingularityException63.getSuppressed();
cardanEulerSingularityException52.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
cardanEulerSingularityException45.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException52);
java.lang.Throwable[] throwableArray73 = cardanEulerSingularityException52.getSuppressed();
java.lang.String str74 = cardanEulerSingularityException52.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray23);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray23), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray23), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray50);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray50), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray50), "[]");
org.junit.Assert.assertNotNull(throwableArray56);
org.junit.Assert.assertNotNull(throwableArray57);
org.junit.Assert.assertEquals("'" + str60 + "' != '" + "Euler angles singularity" + "'", str60, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(throwableArray65);
org.junit.Assert.assertEquals("'" + str66 + "' != '" + "Euler angles singularity" + "'", str66, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray67);
org.junit.Assert.assertEquals("'" + str68 + "' != '" + "Euler angles singularity" + "'", str68, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray69);
org.junit.Assert.assertNotNull(throwableArray73);
org.junit.Assert.assertEquals("'" + str74 + "' != '" + "Cardan angles singularity" + "'", str74, "Cardan angles singularity");
}
@Test
public void test1777() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1777");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray9 = cardanEulerSingularityException6.getSuppressed();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException12 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray13 = cardanEulerSingularityException12.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException12.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException12.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException12);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray31 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException33 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray34 = cardanEulerSingularityException33.getArguments();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException33.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException33.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException33);
java.lang.Object[] objArray38 = cardanEulerSingularityException28.getArguments();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray40 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException44 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException44);
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException42.getSuppressed();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Object[] objArray49 = cardanEulerSingularityException28.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.String str53 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray54 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray55 = cardanEulerSingularityException51.getArguments();
java.lang.String str56 = cardanEulerSingularityException51.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray59 = cardanEulerSingularityException58.getArguments();
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException58.getSuppressed();
java.lang.Throwable[] throwableArray61 = cardanEulerSingularityException58.getSuppressed();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException58);
java.lang.Object[] objArray63 = cardanEulerSingularityException51.getArguments();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.Throwable[] throwableArray65 = cardanEulerSingularityException28.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(throwableArray9);
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(objArray40);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray40), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray40), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "Euler angles singularity" + "'", str56, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertNotNull(throwableArray61);
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(throwableArray65);
}
@Test
public void test1778() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1778");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException8.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException8.getSuppressed();
java.lang.String str35 = cardanEulerSingularityException8.getPattern();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Euler angles singularity" + "'", str35, "Euler angles singularity");
}
@Test
public void test1779() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1779");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
java.lang.Object[] objArray26 = cardanEulerSingularityException24.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException28 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray29 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException24.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.Throwable[] throwableArray31 = cardanEulerSingularityException28.getSuppressed();
java.lang.Object[] objArray32 = cardanEulerSingularityException28.getArguments();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException28);
java.lang.String str34 = cardanEulerSingularityException28.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.String str38 = cardanEulerSingularityException36.getPattern();
java.lang.Object[] objArray39 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray42 = cardanEulerSingularityException41.getArguments();
java.lang.Object[] objArray43 = cardanEulerSingularityException41.getArguments();
java.lang.String str44 = cardanEulerSingularityException41.getPattern();
java.lang.String str45 = cardanEulerSingularityException41.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray49 = cardanEulerSingularityException48.getArguments();
java.lang.String str50 = cardanEulerSingularityException48.getPattern();
java.lang.Object[] objArray51 = cardanEulerSingularityException48.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException48.getArguments();
java.lang.String str53 = cardanEulerSingularityException48.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException48.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
java.lang.String str57 = cardanEulerSingularityException48.getPattern();
java.lang.String str58 = cardanEulerSingularityException48.getPattern();
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
java.lang.Throwable[] throwableArray60 = cardanEulerSingularityException36.getSuppressed();
java.lang.String str61 = cardanEulerSingularityException36.getPattern();
cardanEulerSingularityException28.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException36.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Object[] objArray65 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(throwableArray31);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertEquals("'" + str38 + "' != '" + "Euler angles singularity" + "'", str38, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Cardan angles singularity" + "'", str44, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Cardan angles singularity" + "'", str45, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray49);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray49), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray49), "[]");
org.junit.Assert.assertEquals("'" + str50 + "' != '" + "Euler angles singularity" + "'", str50, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "Euler angles singularity" + "'", str58, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray60);
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
}
@Test
public void test1780() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1780");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.String str8 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.String str12 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Throwable[] throwableArray14 = cardanEulerSingularityException10.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException16.getSuppressed();
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException16.getSuppressed();
java.lang.Throwable[] throwableArray22 = cardanEulerSingularityException16.getSuppressed();
java.lang.String str23 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
java.lang.String str26 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException16.getSuppressed();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Euler angles singularity" + "'", str8, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray14);
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(throwableArray22);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Cardan angles singularity" + "'", str23, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Cardan angles singularity" + "'", str26, "Cardan angles singularity");
org.junit.Assert.assertNotNull(throwableArray27);
}
@Test
public void test1781() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1781");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str2 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException6.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str12 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.String str14 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str17 = cardanEulerSingularityException16.getPattern();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException16.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Object[] objArray24 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str28 = cardanEulerSingularityException27.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.String str39 = cardanEulerSingularityException1.getPattern();
java.lang.String str40 = cardanEulerSingularityException1.getPattern();
java.lang.Class<?> wildcardClass41 = cardanEulerSingularityException1.getClass();
org.junit.Assert.assertEquals("'" + str2 + "' != '" + "Euler angles singularity" + "'", str2, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Euler angles singularity" + "'", str7, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "Euler angles singularity" + "'", str12, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "Euler angles singularity" + "'", str17, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Cardan angles singularity" + "'", str36, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str39 + "' != '" + "Euler angles singularity" + "'", str39, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(wildcardClass41);
}
@Test
public void test1782() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1782");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray5 = cardanEulerSingularityException1.getArguments();
java.lang.String str6 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray9 = cardanEulerSingularityException8.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException8.getSuppressed();
java.lang.Throwable[] throwableArray11 = cardanEulerSingularityException8.getSuppressed();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray15 = cardanEulerSingularityException14.getArguments();
java.lang.Object[] objArray16 = cardanEulerSingularityException14.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.Throwable[] throwableArray21 = cardanEulerSingularityException18.getSuppressed();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str24 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException26 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray27 = cardanEulerSingularityException26.getArguments();
java.lang.String str28 = cardanEulerSingularityException26.getPattern();
java.lang.Object[] objArray29 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
java.lang.String str34 = cardanEulerSingularityException31.getPattern();
java.lang.String str35 = cardanEulerSingularityException31.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException38 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray39 = cardanEulerSingularityException38.getArguments();
java.lang.String str40 = cardanEulerSingularityException38.getPattern();
java.lang.Object[] objArray41 = cardanEulerSingularityException38.getArguments();
java.lang.Object[] objArray42 = cardanEulerSingularityException38.getArguments();
java.lang.String str43 = cardanEulerSingularityException38.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException45 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException38.addSuppressed((java.lang.Throwable) cardanEulerSingularityException45);
java.lang.String str47 = cardanEulerSingularityException38.getPattern();
java.lang.String str48 = cardanEulerSingularityException38.getPattern();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException38);
java.lang.Throwable[] throwableArray50 = cardanEulerSingularityException26.getSuppressed();
java.lang.String str51 = cardanEulerSingularityException26.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException26);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException26.getSuppressed();
java.lang.Object[] objArray54 = cardanEulerSingularityException26.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException56 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str57 = cardanEulerSingularityException56.getPattern();
java.lang.Object[] objArray58 = cardanEulerSingularityException56.getArguments();
java.lang.String str59 = cardanEulerSingularityException56.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException61 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str62 = cardanEulerSingularityException61.getPattern();
java.lang.Throwable[] throwableArray63 = cardanEulerSingularityException61.getSuppressed();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException61);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException66 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str67 = cardanEulerSingularityException66.getPattern();
java.lang.Object[] objArray68 = cardanEulerSingularityException66.getArguments();
java.lang.String str69 = cardanEulerSingularityException66.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException71 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str72 = cardanEulerSingularityException71.getPattern();
java.lang.Throwable[] throwableArray73 = cardanEulerSingularityException71.getSuppressed();
cardanEulerSingularityException66.addSuppressed((java.lang.Throwable) cardanEulerSingularityException71);
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException66);
java.lang.String str76 = cardanEulerSingularityException56.getPattern();
java.lang.String str77 = cardanEulerSingularityException56.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException79 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray80 = cardanEulerSingularityException79.getArguments();
java.lang.String str81 = cardanEulerSingularityException79.getPattern();
java.lang.Object[] objArray82 = cardanEulerSingularityException79.getArguments();
java.lang.Object[] objArray83 = cardanEulerSingularityException79.getArguments();
java.lang.String str84 = cardanEulerSingularityException79.getPattern();
cardanEulerSingularityException56.addSuppressed((java.lang.Throwable) cardanEulerSingularityException79);
java.lang.Throwable[] throwableArray86 = cardanEulerSingularityException56.getSuppressed();
cardanEulerSingularityException26.addSuppressed((java.lang.Throwable) cardanEulerSingularityException56);
java.lang.String str88 = cardanEulerSingularityException26.getPattern();
java.lang.String str89 = cardanEulerSingularityException26.getPattern();
java.lang.String str90 = cardanEulerSingularityException26.getPattern();
java.lang.String str91 = cardanEulerSingularityException26.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray5);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray5), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray5), "[]");
org.junit.Assert.assertEquals("'" + str6 + "' != '" + "Euler angles singularity" + "'", str6, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(throwableArray11);
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray21);
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
org.junit.Assert.assertEquals("'" + str28 + "' != '" + "Euler angles singularity" + "'", str28, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "Cardan angles singularity" + "'", str35, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(objArray42);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray42), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray42), "[]");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray50);
org.junit.Assert.assertEquals("'" + str51 + "' != '" + "Euler angles singularity" + "'", str51, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(objArray54);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray54), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray54), "[]");
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "Euler angles singularity" + "'", str57, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray58);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray58), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray58), "[]");
org.junit.Assert.assertEquals("'" + str59 + "' != '" + "Euler angles singularity" + "'", str59, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "Euler angles singularity" + "'", str62, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray63);
org.junit.Assert.assertEquals("'" + str67 + "' != '" + "Euler angles singularity" + "'", str67, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertEquals("'" + str69 + "' != '" + "Euler angles singularity" + "'", str69, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str72 + "' != '" + "Euler angles singularity" + "'", str72, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray73);
org.junit.Assert.assertEquals("'" + str76 + "' != '" + "Euler angles singularity" + "'", str76, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str77 + "' != '" + "Euler angles singularity" + "'", str77, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray80);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray80), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray80), "[]");
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "Euler angles singularity" + "'", str81, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray83);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray83), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray83), "[]");
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray86);
org.junit.Assert.assertEquals("'" + str88 + "' != '" + "Euler angles singularity" + "'", str88, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str89 + "' != '" + "Euler angles singularity" + "'", str89, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str90 + "' != '" + "Euler angles singularity" + "'", str90, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str91 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str91, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1783() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1783");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray16 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.String str31 = cardanEulerSingularityException13.getPattern();
java.lang.String str32 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray33 = cardanEulerSingularityException13.getArguments();
java.lang.String str34 = cardanEulerSingularityException13.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertNotNull(throwableArray16);
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Cardan angles singularity" + "'", str31, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "Cardan angles singularity" + "'", str32, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Cardan angles singularity" + "'", str34, "Cardan angles singularity");
}
@Test
public void test1784() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1784");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
java.lang.String str9 = cardanEulerSingularityException6.getPattern();
java.lang.String str10 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray14 = cardanEulerSingularityException13.getArguments();
java.lang.String str15 = cardanEulerSingularityException13.getPattern();
java.lang.Object[] objArray16 = cardanEulerSingularityException13.getArguments();
java.lang.Object[] objArray17 = cardanEulerSingularityException13.getArguments();
java.lang.String str18 = cardanEulerSingularityException13.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.String str22 = cardanEulerSingularityException13.getPattern();
java.lang.String str23 = cardanEulerSingularityException13.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray26 = cardanEulerSingularityException1.getSuppressed();
java.lang.Class<?> wildcardClass27 = throwableArray26.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Cardan angles singularity" + "'", str9, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Cardan angles singularity" + "'", str10, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "Euler angles singularity" + "'", str15, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "Euler angles singularity" + "'", str18, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Euler angles singularity" + "'", str22, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray26);
org.junit.Assert.assertNotNull(wildcardClass27);
}
@Test
public void test1785() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1785");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray4 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray8 = cardanEulerSingularityException7.getArguments();
java.lang.Object[] objArray9 = cardanEulerSingularityException7.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException7.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray20 = cardanEulerSingularityException19.getArguments();
java.lang.Object[] objArray21 = cardanEulerSingularityException19.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
java.lang.String str26 = cardanEulerSingularityException23.getPattern();
java.lang.String str27 = cardanEulerSingularityException23.getPattern();
java.lang.Object[] objArray28 = cardanEulerSingularityException23.getArguments();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.String str33 = cardanEulerSingularityException31.getPattern();
java.lang.Object[] objArray34 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Throwable[] throwableArray38 = cardanEulerSingularityException36.getSuppressed();
java.lang.Throwable[] throwableArray39 = cardanEulerSingularityException36.getSuppressed();
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException36.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray43 = cardanEulerSingularityException42.getArguments();
java.lang.Object[] objArray44 = cardanEulerSingularityException42.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException48 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException48);
cardanEulerSingularityException42.addSuppressed((java.lang.Throwable) cardanEulerSingularityException46);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
java.lang.Throwable[] throwableArray53 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray54 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException19);
java.lang.String str57 = cardanEulerSingularityException19.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertNotNull(throwableArray4);
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray34);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray34), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray34), "[]");
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(throwableArray38);
org.junit.Assert.assertNotNull(throwableArray39);
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertNotNull(objArray43);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray43), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray43), "[]");
org.junit.Assert.assertNotNull(objArray44);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray44), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray44), "[]");
org.junit.Assert.assertNotNull(throwableArray53);
org.junit.Assert.assertNotNull(throwableArray54);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str57, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1786() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1786");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.Throwable[] throwableArray5 = cardanEulerSingularityException1.getSuppressed();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException1.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str19 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray20 = cardanEulerSingularityException18.getArguments();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str24 = cardanEulerSingularityException23.getPattern();
java.lang.Throwable[] throwableArray25 = cardanEulerSingularityException23.getSuppressed();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException23);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException29 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException29);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException8);
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException8.getSuppressed();
java.lang.Object[] objArray33 = cardanEulerSingularityException8.getArguments();
java.lang.String str34 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray35 = cardanEulerSingularityException8.getArguments();
org.junit.Assert.assertNotNull(throwableArray5);
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "Euler angles singularity" + "'", str19, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray20);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray20), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray20), "[]");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray25);
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "Euler angles singularity" + "'", str34, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
}
@Test
public void test1787() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1787");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray17 = cardanEulerSingularityException16.getArguments();
java.lang.Object[] objArray18 = cardanEulerSingularityException16.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
cardanEulerSingularityException16.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException16.getSuppressed();
java.lang.String str24 = cardanEulerSingularityException16.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
java.lang.Object[] objArray29 = cardanEulerSingularityException27.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException31.getSuppressed();
java.lang.Object[] objArray35 = cardanEulerSingularityException31.getArguments();
java.lang.Throwable[] throwableArray36 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
java.lang.Object[] objArray38 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray39 = cardanEulerSingularityException31.getArguments();
java.lang.String str40 = cardanEulerSingularityException31.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray17);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray17), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray17), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(objArray35);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray35), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray35), "[]");
org.junit.Assert.assertNotNull(throwableArray36);
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray39);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray39), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray39), "[]");
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "Euler angles singularity" + "'", str40, "Euler angles singularity");
}
@Test
public void test1788() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1788");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
java.lang.Class<?> wildcardClass19 = cardanEulerSingularityException11.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(wildcardClass19);
}
@Test
public void test1789() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1789");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.String str3 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray10 = cardanEulerSingularityException1.getArguments();
java.lang.String str11 = cardanEulerSingularityException1.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "Euler angles singularity" + "'", str3, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
}
@Test
public void test1790() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1790");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray13 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
java.lang.Object[] objArray16 = cardanEulerSingularityException11.getArguments();
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException11.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray21 = cardanEulerSingularityException20.getArguments();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException24 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray25 = cardanEulerSingularityException24.getArguments();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException24.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException24);
java.lang.Throwable[] throwableArray29 = cardanEulerSingularityException11.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray36 = cardanEulerSingularityException35.getArguments();
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Object[] objArray38 = cardanEulerSingularityException35.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray41 = cardanEulerSingularityException40.getArguments();
java.lang.Throwable[] throwableArray42 = cardanEulerSingularityException40.getSuppressed();
java.lang.String str43 = cardanEulerSingularityException40.getPattern();
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
java.lang.Object[] objArray45 = cardanEulerSingularityException35.getArguments();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException35.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray48 = cardanEulerSingularityException11.getSuppressed();
java.lang.String str49 = cardanEulerSingularityException11.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray13);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray13), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray13), "[]");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray16);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray16), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray16), "[]");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertNotNull(objArray21);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray21), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray21), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertNotNull(throwableArray29);
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(objArray36);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray36), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray36), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray41);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray41), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray41), "[]");
org.junit.Assert.assertNotNull(throwableArray42);
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray45);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray45), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray45), "[]");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertNotNull(throwableArray48);
org.junit.Assert.assertEquals("'" + str49 + "' != '" + "Euler angles singularity" + "'", str49, "Euler angles singularity");
}
@Test
public void test1791() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1791");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException3 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException3);
java.lang.String str5 = cardanEulerSingularityException3.getPattern();
java.lang.Throwable[] throwableArray6 = cardanEulerSingularityException3.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException8 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str9 = cardanEulerSingularityException8.getPattern();
java.lang.Object[] objArray10 = cardanEulerSingularityException8.getArguments();
java.lang.String str11 = cardanEulerSingularityException8.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str14 = cardanEulerSingularityException13.getPattern();
java.lang.Throwable[] throwableArray15 = cardanEulerSingularityException13.getSuppressed();
cardanEulerSingularityException8.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException19 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str20 = cardanEulerSingularityException19.getPattern();
java.lang.String str21 = cardanEulerSingularityException19.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray26 = cardanEulerSingularityException25.getArguments();
java.lang.String str27 = cardanEulerSingularityException25.getPattern();
java.lang.Object[] objArray28 = cardanEulerSingularityException25.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray31 = cardanEulerSingularityException30.getArguments();
java.lang.Throwable[] throwableArray32 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException30.getSuppressed();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException30.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException36 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray37 = cardanEulerSingularityException36.getArguments();
java.lang.Object[] objArray38 = cardanEulerSingularityException36.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException40 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException42 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException40.addSuppressed((java.lang.Throwable) cardanEulerSingularityException42);
cardanEulerSingularityException36.addSuppressed((java.lang.Throwable) cardanEulerSingularityException40);
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException36);
cardanEulerSingularityException25.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
java.lang.Object[] objArray47 = cardanEulerSingularityException25.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException19.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
cardanEulerSingularityException3.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
java.lang.Object[] objArray51 = cardanEulerSingularityException3.getArguments();
java.lang.Class<?> wildcardClass52 = cardanEulerSingularityException3.getClass();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "Euler angles singularity" + "'", str5, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray6);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray10);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray10), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray10), "[]");
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Euler angles singularity" + "'", str11, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Euler angles singularity" + "'", str14, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray15);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Cardan angles singularity" + "'", str20, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Cardan angles singularity" + "'", str21, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray31);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray31), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray31), "[]");
org.junit.Assert.assertNotNull(throwableArray32);
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(objArray37);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray37), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray37), "[]");
org.junit.Assert.assertNotNull(objArray38);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray38), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray38), "[]");
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(wildcardClass52);
}
@Test
public void test1792() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1792");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
java.lang.String str9 = cardanEulerSingularityException7.getPattern();
java.lang.String str10 = cardanEulerSingularityException7.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException13 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException15 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException15);
java.lang.Throwable[] throwableArray17 = cardanEulerSingularityException13.getSuppressed();
java.lang.Throwable[] throwableArray18 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str21 = cardanEulerSingularityException20.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException20.getArguments();
java.lang.String str23 = cardanEulerSingularityException20.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException25 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str26 = cardanEulerSingularityException25.getPattern();
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException25.getSuppressed();
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException25);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException30 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str31 = cardanEulerSingularityException30.getPattern();
java.lang.Object[] objArray32 = cardanEulerSingularityException30.getArguments();
java.lang.String str33 = cardanEulerSingularityException30.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str36 = cardanEulerSingularityException35.getPattern();
java.lang.Throwable[] throwableArray37 = cardanEulerSingularityException35.getSuppressed();
cardanEulerSingularityException30.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException30);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException20);
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException13.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException46 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray47 = cardanEulerSingularityException46.getArguments();
java.lang.Object[] objArray48 = cardanEulerSingularityException46.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException50);
java.lang.String str53 = cardanEulerSingularityException46.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
java.lang.Object[] objArray57 = cardanEulerSingularityException55.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException59 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray60 = cardanEulerSingularityException59.getArguments();
cardanEulerSingularityException55.addSuppressed((java.lang.Throwable) cardanEulerSingularityException59);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException63 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray64 = cardanEulerSingularityException63.getArguments();
java.lang.Object[] objArray65 = cardanEulerSingularityException63.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException69 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException67.addSuppressed((java.lang.Throwable) cardanEulerSingularityException69);
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
java.lang.Throwable[] throwableArray72 = cardanEulerSingularityException63.getSuppressed();
cardanEulerSingularityException59.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
java.lang.String str74 = cardanEulerSingularityException63.getPattern();
cardanEulerSingularityException46.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException77 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray78 = cardanEulerSingularityException77.getArguments();
java.lang.Object[] objArray79 = cardanEulerSingularityException77.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException81 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray82 = cardanEulerSingularityException81.getArguments();
cardanEulerSingularityException77.addSuppressed((java.lang.Throwable) cardanEulerSingularityException81);
java.lang.Object[] objArray84 = cardanEulerSingularityException81.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException86 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray87 = cardanEulerSingularityException86.getArguments();
java.lang.Throwable[] throwableArray88 = cardanEulerSingularityException86.getSuppressed();
java.lang.String str89 = cardanEulerSingularityException86.getPattern();
cardanEulerSingularityException81.addSuppressed((java.lang.Throwable) cardanEulerSingularityException86);
java.lang.Object[] objArray91 = cardanEulerSingularityException81.getArguments();
java.lang.Throwable[] throwableArray92 = cardanEulerSingularityException81.getSuppressed();
cardanEulerSingularityException63.addSuppressed((java.lang.Throwable) cardanEulerSingularityException81);
cardanEulerSingularityException13.addSuppressed((java.lang.Throwable) cardanEulerSingularityException63);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException13);
java.lang.Object[] objArray96 = cardanEulerSingularityException1.getArguments();
java.lang.String str97 = cardanEulerSingularityException1.getPattern();
java.lang.Object[] objArray98 = cardanEulerSingularityException1.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray17);
org.junit.Assert.assertNotNull(throwableArray18);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Euler angles singularity" + "'", str21, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "Euler angles singularity" + "'", str23, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str31 + "' != '" + "Euler angles singularity" + "'", str31, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertEquals("'" + str33 + "' != '" + "Euler angles singularity" + "'", str33, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Euler angles singularity" + "'", str36, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray37);
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertNotNull(objArray47);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray47), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray47), "[]");
org.junit.Assert.assertNotNull(objArray48);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray48), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray48), "[]");
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertEquals("'" + str53 + "' != '" + "Euler angles singularity" + "'", str53, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(objArray57);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray57), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray57), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray64);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray64), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray64), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(throwableArray72);
org.junit.Assert.assertEquals("'" + str74 + "' != '" + "Euler angles singularity" + "'", str74, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray78);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray78), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray78), "[]");
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
org.junit.Assert.assertNotNull(objArray82);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray82), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray82), "[]");
org.junit.Assert.assertNotNull(objArray84);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray84), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray84), "[]");
org.junit.Assert.assertNotNull(objArray87);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray87), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray87), "[]");
org.junit.Assert.assertNotNull(throwableArray88);
org.junit.Assert.assertEquals("'" + str89 + "' != '" + "Euler angles singularity" + "'", str89, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray91);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray91), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray91), "[]");
org.junit.Assert.assertNotNull(throwableArray92);
org.junit.Assert.assertNotNull(objArray96);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray96), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray96), "[]");
org.junit.Assert.assertEquals("'" + str97 + "' != '" + "Cardan angles singularity" + "'", str97, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray98);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray98), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray98), "[]");
}
@Test
public void test1793() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1793");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Throwable[] throwableArray3 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str4 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.String str7 = cardanEulerSingularityException6.getPattern();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
java.lang.Object[] objArray9 = cardanEulerSingularityException6.getArguments();
java.lang.Throwable[] throwableArray10 = cardanEulerSingularityException6.getSuppressed();
java.lang.Object[] objArray11 = cardanEulerSingularityException6.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(throwableArray3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "Euler angles singularity" + "'", str4, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Cardan angles singularity" + "'", str7, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertNotNull(throwableArray10);
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
}
@Test
public void test1794() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1794");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray19 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException18.getSuppressed();
java.lang.String str21 = cardanEulerSingularityException18.getPattern();
java.lang.Object[] objArray22 = cardanEulerSingularityException18.getArguments();
java.lang.Throwable[] throwableArray23 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str25 = cardanEulerSingularityException5.getPattern();
java.lang.Object[] objArray26 = cardanEulerSingularityException5.getArguments();
java.lang.Object[] objArray27 = cardanEulerSingularityException5.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "Cardan angles singularity" + "'", str21, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray23);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Cardan angles singularity" + "'", str25, "Cardan angles singularity");
org.junit.Assert.assertNotNull(objArray26);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray26), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray26), "[]");
org.junit.Assert.assertNotNull(objArray27);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray27), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray27), "[]");
}
@Test
public void test1795() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1795");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException1.getSuppressed();
java.lang.String str9 = cardanEulerSingularityException1.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
java.lang.String str16 = cardanEulerSingularityException11.getPattern();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str21 = cardanEulerSingularityException18.toString();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "Euler angles singularity" + "'", str9, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str16 + "' != '" + "Euler angles singularity" + "'", str16, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity" + "'", str21, "org.apache.commons.math.geometry.CardanEulerSingularityException: Euler angles singularity");
}
@Test
public void test1796() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1796");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Object[] objArray8 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Throwable[] throwableArray12 = cardanEulerSingularityException10.getSuppressed();
java.lang.String str13 = cardanEulerSingularityException10.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException10);
java.lang.Object[] objArray15 = cardanEulerSingularityException5.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException17 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray18 = cardanEulerSingularityException17.getArguments();
java.lang.Object[] objArray19 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException21 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray22 = cardanEulerSingularityException21.getArguments();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException21);
java.lang.Throwable[] throwableArray24 = cardanEulerSingularityException17.getSuppressed();
java.lang.String str25 = cardanEulerSingularityException17.getPattern();
java.lang.String str26 = cardanEulerSingularityException17.getPattern();
java.lang.String str27 = cardanEulerSingularityException17.getPattern();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException17);
java.lang.Object[] objArray29 = cardanEulerSingularityException17.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Throwable[] throwableArray33 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray34 = cardanEulerSingularityException31.getSuppressed();
java.lang.Throwable[] throwableArray35 = cardanEulerSingularityException31.getSuppressed();
java.lang.String str36 = cardanEulerSingularityException31.getPattern();
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException39 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException41 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException39.addSuppressed((java.lang.Throwable) cardanEulerSingularityException41);
java.lang.String str43 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray44 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str45 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray46 = cardanEulerSingularityException41.getSuppressed();
java.lang.String str47 = cardanEulerSingularityException41.getPattern();
java.lang.String str48 = cardanEulerSingularityException41.getPattern();
java.lang.Throwable[] throwableArray49 = cardanEulerSingularityException41.getSuppressed();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException51 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray52 = cardanEulerSingularityException51.getArguments();
java.lang.Object[] objArray53 = cardanEulerSingularityException51.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException55 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray56 = cardanEulerSingularityException55.getArguments();
cardanEulerSingularityException51.addSuppressed((java.lang.Throwable) cardanEulerSingularityException55);
java.lang.Throwable[] throwableArray58 = cardanEulerSingularityException51.getSuppressed();
cardanEulerSingularityException41.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
cardanEulerSingularityException17.addSuppressed((java.lang.Throwable) cardanEulerSingularityException51);
java.lang.String str61 = cardanEulerSingularityException51.getPattern();
java.lang.Object[] objArray62 = cardanEulerSingularityException51.getArguments();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(throwableArray12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertNotNull(objArray18);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray18), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray18), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(objArray22);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray22), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray22), "[]");
org.junit.Assert.assertNotNull(throwableArray24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "Euler angles singularity" + "'", str26, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "Euler angles singularity" + "'", str27, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray29);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray29), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray29), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(throwableArray33);
org.junit.Assert.assertNotNull(throwableArray34);
org.junit.Assert.assertNotNull(throwableArray35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "Cardan angles singularity" + "'", str36, "Cardan angles singularity");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "Euler angles singularity" + "'", str43, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray44);
org.junit.Assert.assertEquals("'" + str45 + "' != '" + "Euler angles singularity" + "'", str45, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray46);
org.junit.Assert.assertEquals("'" + str47 + "' != '" + "Euler angles singularity" + "'", str47, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "Euler angles singularity" + "'", str48, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray49);
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray53);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray53), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray53), "[]");
org.junit.Assert.assertNotNull(objArray56);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray56), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray56), "[]");
org.junit.Assert.assertNotNull(throwableArray58);
org.junit.Assert.assertEquals("'" + str61 + "' != '" + "Euler angles singularity" + "'", str61, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray62);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray62), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray62), "[]");
}
@Test
public void test1797() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1797");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray4 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException6 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray7 = cardanEulerSingularityException6.getArguments();
java.lang.Object[] objArray8 = cardanEulerSingularityException6.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException10 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray11 = cardanEulerSingularityException10.getArguments();
java.lang.Object[] objArray12 = cardanEulerSingularityException10.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException14 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException16 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException14.addSuppressed((java.lang.Throwable) cardanEulerSingularityException16);
cardanEulerSingularityException10.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
java.lang.Object[] objArray19 = cardanEulerSingularityException14.getArguments();
java.lang.Throwable[] throwableArray20 = cardanEulerSingularityException14.getSuppressed();
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException14);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException23 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray24 = cardanEulerSingularityException23.getArguments();
java.lang.Object[] objArray25 = cardanEulerSingularityException23.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException27 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray28 = cardanEulerSingularityException27.getArguments();
cardanEulerSingularityException23.addSuppressed((java.lang.Throwable) cardanEulerSingularityException27);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException31 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray32 = cardanEulerSingularityException31.getArguments();
java.lang.Object[] objArray33 = cardanEulerSingularityException31.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException35 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException37 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException35.addSuppressed((java.lang.Throwable) cardanEulerSingularityException37);
cardanEulerSingularityException31.addSuppressed((java.lang.Throwable) cardanEulerSingularityException35);
java.lang.Throwable[] throwableArray40 = cardanEulerSingularityException31.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException31);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException43 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.String str44 = cardanEulerSingularityException43.getPattern();
java.lang.Throwable[] throwableArray45 = cardanEulerSingularityException43.getSuppressed();
cardanEulerSingularityException27.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException43);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException6);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException50 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray51 = cardanEulerSingularityException50.getArguments();
java.lang.Object[] objArray52 = cardanEulerSingularityException50.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException54 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray55 = cardanEulerSingularityException54.getArguments();
cardanEulerSingularityException50.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException58 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray59 = cardanEulerSingularityException58.getArguments();
java.lang.Object[] objArray60 = cardanEulerSingularityException58.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException62 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray63 = cardanEulerSingularityException62.getArguments();
cardanEulerSingularityException58.addSuppressed((java.lang.Throwable) cardanEulerSingularityException62);
java.lang.Object[] objArray65 = cardanEulerSingularityException62.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException67 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray68 = cardanEulerSingularityException67.getArguments();
java.lang.Throwable[] throwableArray69 = cardanEulerSingularityException67.getSuppressed();
java.lang.String str70 = cardanEulerSingularityException67.getPattern();
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException67);
java.lang.Object[] objArray72 = cardanEulerSingularityException62.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException74 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray75 = cardanEulerSingularityException74.getArguments();
java.lang.Object[] objArray76 = cardanEulerSingularityException74.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException78 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray79 = cardanEulerSingularityException78.getArguments();
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException78);
java.lang.Throwable[] throwableArray81 = cardanEulerSingularityException74.getSuppressed();
java.lang.String str82 = cardanEulerSingularityException74.getPattern();
java.lang.String str83 = cardanEulerSingularityException74.getPattern();
java.lang.String str84 = cardanEulerSingularityException74.getPattern();
cardanEulerSingularityException62.addSuppressed((java.lang.Throwable) cardanEulerSingularityException74);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException87 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray88 = cardanEulerSingularityException87.getArguments();
cardanEulerSingularityException74.addSuppressed((java.lang.Throwable) cardanEulerSingularityException87);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException91 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
java.lang.Object[] objArray92 = cardanEulerSingularityException91.getArguments();
java.lang.Object[] objArray93 = cardanEulerSingularityException91.getArguments();
java.lang.Object[] objArray94 = cardanEulerSingularityException91.getArguments();
java.lang.String str95 = cardanEulerSingularityException91.getPattern();
cardanEulerSingularityException87.addSuppressed((java.lang.Throwable) cardanEulerSingularityException91);
cardanEulerSingularityException54.addSuppressed((java.lang.Throwable) cardanEulerSingularityException91);
cardanEulerSingularityException6.addSuppressed((java.lang.Throwable) cardanEulerSingularityException54);
java.lang.Class<?> wildcardClass99 = cardanEulerSingularityException54.getClass();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray4);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray4), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray4), "[]");
org.junit.Assert.assertNotNull(objArray7);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray7), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray7), "[]");
org.junit.Assert.assertNotNull(objArray8);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray8), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray8), "[]");
org.junit.Assert.assertNotNull(objArray11);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray11), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray11), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertNotNull(objArray19);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray19), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray19), "[]");
org.junit.Assert.assertNotNull(throwableArray20);
org.junit.Assert.assertNotNull(objArray24);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray24), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray24), "[]");
org.junit.Assert.assertNotNull(objArray25);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray25), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray25), "[]");
org.junit.Assert.assertNotNull(objArray28);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray28), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray28), "[]");
org.junit.Assert.assertNotNull(objArray32);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray32), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray32), "[]");
org.junit.Assert.assertNotNull(objArray33);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray33), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray33), "[]");
org.junit.Assert.assertNotNull(throwableArray40);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "Euler angles singularity" + "'", str44, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray45);
org.junit.Assert.assertNotNull(objArray51);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray51), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray51), "[]");
org.junit.Assert.assertNotNull(objArray52);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray52), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray52), "[]");
org.junit.Assert.assertNotNull(objArray55);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray55), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray55), "[]");
org.junit.Assert.assertNotNull(objArray59);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray59), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray59), "[]");
org.junit.Assert.assertNotNull(objArray60);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray60), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray60), "[]");
org.junit.Assert.assertNotNull(objArray63);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray63), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray63), "[]");
org.junit.Assert.assertNotNull(objArray65);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray65), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray65), "[]");
org.junit.Assert.assertNotNull(objArray68);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray68), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray68), "[]");
org.junit.Assert.assertNotNull(throwableArray69);
org.junit.Assert.assertEquals("'" + str70 + "' != '" + "Euler angles singularity" + "'", str70, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray72);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray72), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray72), "[]");
org.junit.Assert.assertNotNull(objArray75);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray75), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray75), "[]");
org.junit.Assert.assertNotNull(objArray76);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray76), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray76), "[]");
org.junit.Assert.assertNotNull(objArray79);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray79), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray79), "[]");
org.junit.Assert.assertNotNull(throwableArray81);
org.junit.Assert.assertEquals("'" + str82 + "' != '" + "Euler angles singularity" + "'", str82, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str83 + "' != '" + "Euler angles singularity" + "'", str83, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str84 + "' != '" + "Euler angles singularity" + "'", str84, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray88);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray88), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray88), "[]");
org.junit.Assert.assertNotNull(objArray92);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray92), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray92), "[]");
org.junit.Assert.assertNotNull(objArray93);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray93), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray93), "[]");
org.junit.Assert.assertNotNull(objArray94);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray94), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray94), "[]");
org.junit.Assert.assertEquals("'" + str95 + "' != '" + "Cardan angles singularity" + "'", str95, "Cardan angles singularity");
org.junit.Assert.assertNotNull(wildcardClass99);
}
@Test
public void test1798() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1798");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray6 = cardanEulerSingularityException5.getArguments();
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
java.lang.Throwable[] throwableArray8 = cardanEulerSingularityException5.getSuppressed();
java.lang.Object[] objArray9 = cardanEulerSingularityException5.getArguments();
java.lang.String str10 = cardanEulerSingularityException5.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray6);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray6), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray6), "[]");
org.junit.Assert.assertNotNull(throwableArray8);
org.junit.Assert.assertNotNull(objArray9);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray9), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray9), "[]");
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Euler angles singularity" + "'", str10, "Euler angles singularity");
}
@Test
public void test1799() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1799");
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException1 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray2 = cardanEulerSingularityException1.getArguments();
java.lang.Object[] objArray3 = cardanEulerSingularityException1.getArguments();
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException5 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException7 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException7);
cardanEulerSingularityException1.addSuppressed((java.lang.Throwable) cardanEulerSingularityException5);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException11 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
java.lang.Object[] objArray12 = cardanEulerSingularityException11.getArguments();
java.lang.String str13 = cardanEulerSingularityException11.getPattern();
java.lang.Object[] objArray14 = cardanEulerSingularityException11.getArguments();
java.lang.Object[] objArray15 = cardanEulerSingularityException11.getArguments();
cardanEulerSingularityException5.addSuppressed((java.lang.Throwable) cardanEulerSingularityException11);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException18 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException20 = new org.apache.commons.math.geometry.CardanEulerSingularityException(true);
org.apache.commons.math.geometry.CardanEulerSingularityException cardanEulerSingularityException22 = new org.apache.commons.math.geometry.CardanEulerSingularityException(false);
cardanEulerSingularityException20.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.String str24 = cardanEulerSingularityException22.getPattern();
java.lang.String str25 = cardanEulerSingularityException22.getPattern();
cardanEulerSingularityException18.addSuppressed((java.lang.Throwable) cardanEulerSingularityException22);
java.lang.Throwable[] throwableArray27 = cardanEulerSingularityException18.getSuppressed();
cardanEulerSingularityException11.addSuppressed((java.lang.Throwable) cardanEulerSingularityException18);
java.lang.String str29 = cardanEulerSingularityException18.getPattern();
org.junit.Assert.assertNotNull(objArray2);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray2), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray2), "[]");
org.junit.Assert.assertNotNull(objArray3);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray3), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray3), "[]");
org.junit.Assert.assertNotNull(objArray12);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray12), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray12), "[]");
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "Euler angles singularity" + "'", str13, "Euler angles singularity");
org.junit.Assert.assertNotNull(objArray14);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray14), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray14), "[]");
org.junit.Assert.assertNotNull(objArray15);
org.junit.Assert.assertEquals(java.util.Arrays.deepToString(objArray15), "[]");
org.junit.Assert.assertEquals(java.util.Arrays.toString(objArray15), "[]");
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "Euler angles singularity" + "'", str24, "Euler angles singularity");
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "Euler angles singularity" + "'", str25, "Euler angles singularity");
org.junit.Assert.assertNotNull(throwableArray27);
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "Cardan angles singularity" + "'", str29, "Cardan angles singularity");
}
}
| [
"[email protected]"
] | |
037c9341e40cf58db54db3a52adb138b1dce0273 | 9a70eeb61f4641c98dc8068dd7dacc287241dd22 | /src/main/java/net/bot/scenario/Scenario.java | 36ce1251c392951946d8641148c453fbbaee0ea2 | [] | no_license | DmitryBelenov/Telegram-Bot | 2e6ab66fe5976c6dcac1f0f243e7128819033be2 | a1167b79db314c07f93cfe836c9bd16585964062 | refs/heads/master | 2023-01-22T15:31:08.185910 | 2020-12-06T21:25:09 | 2020-12-06T21:25:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 304 | java | package net.bot.scenario;
import java.util.List;
public interface Scenario {
List<Object> init(final Long chatId);
List<Object> getReplyType(final Long chatId, final String income);
default boolean btnCallbackChecked(final String income) {
return !income.startsWith("__");
}
}
| [
"[email protected]"
] | |
0ef235aed207b96020fb47023b33874dd632ee54 | f651623d8b4f8c75245eae3d7e8a8ca399b4058b | /cms-springcloud-parent/cms-systemconfig/src/main/java/com/icare/cms/systemconfig/config/DataSourceConfig.java | 8e9ddea0082cdb9800b6139bad7e88c92beda6bd | [] | no_license | panxiangfei/cms | 2c735dc17141de0d52b89edf1ca1bd750b0ea3fe | 535f076249b2565a66462b48f0fe1737f84f51aa | refs/heads/master | 2021-05-11T10:04:59.649075 | 2018-01-19T07:33:37 | 2018-01-19T07:33:37 | 118,093,085 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,272 | java | //package com.icare.cms.systemconfig.config;
//
//import java.beans.PropertyVetoException;
//
//import javax.sql.DataSource;
//
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;
//import org.springframework.context.annotation.PropertySource;
//
//import com.mchange.v2.c3p0.ComboPooledDataSource;
//@Configuration
//@PropertySource(value = {"classpath:jdbc.properties"})
//public class DataSourceConfig{
// protected Logger logger = LoggerFactory.getLogger(this.getClass());
//
// @Value("${jdbc.jdbcUrl}")
// private String jdbcUrl;
//
// @Value("${jdbc.driverClass}")
// private String jdbcDriverClassName;
//
// @Value("${jdbc.user}")
// private String jdbcUsername;
//
// @Value("${jdbc.password}")
// private String jdbcPassword;
//
// @Bean(destroyMethod = "close")
// public DataSource dataSource() {
// ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
// // 数据库驱动
// try {
// comboPooledDataSource.setDriverClass(jdbcDriverClassName);
// } catch (PropertyVetoException e) {
// logger.error("设置数据库驱动"+jdbcDriverClassName+"出错,出错原因:"+e.getMessage());
// }
// comboPooledDataSource.setJdbcUrl(jdbcUrl); // 相应驱动的jdbcUrl
// comboPooledDataSource.setUser(jdbcUsername); // 数据库的用户名
// comboPooledDataSource.setPassword(jdbcUsername); // 数据库的密码
// comboPooledDataSource.setMinPoolSize(10);
// comboPooledDataSource.setMaxPoolSize(100);
// comboPooledDataSource.setInitialPoolSize(10);
// comboPooledDataSource.setAcquireIncrement(5);
// comboPooledDataSource.setMaxStatements(0);
// comboPooledDataSource.setCheckoutTimeout(100);
// comboPooledDataSource.setIdleConnectionTestPeriod(60);
// comboPooledDataSource.setBreakAfterAcquireFailure(false);
// comboPooledDataSource.setTestConnectionOnCheckin(true);
// comboPooledDataSource.setTestConnectionOnCheckout(true);
// return comboPooledDataSource;
// }
//}
| [
"[email protected]"
] | |
1ad56569025d140ec192f03fcd8a89c9b9ff9750 | 00f02acf71fbf38d053a59892ff8cb3226c0c113 | /art/src/main/java/me/jessyan/art/mvp/IRepositoryManager.java | db2bb944e62716edfb8bc6f8cbf0d11f81e4115a | [] | no_license | miaotingxu/ArtFrame | 345405f45517e75f21decbfbd42add8a22d3746c | e023ce215fa48d2b83000a69718240a282a0874f | refs/heads/master | 2021-05-16T21:09:48.382133 | 2020-02-28T05:07:53 | 2020-02-28T05:07:53 | 250,470,324 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,269 | java | /*
* Copyright 2017 JessYan
*
* 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 me.jessyan.art.mvp;
import android.content.Context;
import androidx.annotation.NonNull;
/**
* ================================================
* 用来管理网络请求层,以及数据缓存层,以后可能添加数据库请求层
* 提供给 {@link IModel} 必要的 Api 做数据处理
*
* @see <a href="https://github.com/JessYanCoding/MVPArms/wiki#2.3">RepositoryManager wiki 官方文档</a>
* Created by JessYan on 17/03/2017 11:15
* <a href="mailto:[email protected]">Contact me</a>
* <a href="https://github.com/JessYanCoding">Follow me</a>
* ================================================
*/
public interface IRepositoryManager {
/**
* 根据传入的 Class 创建对应的仓库
*
* @param repository 仓库 class
* @param <T> 仓库 类型
* @return 仓库
*/
@NonNull
<T extends IModel> T createRepository(@NonNull Class<T> repository);
/**
* 根据传入的 Class 创建对应的 Retrofit service
*
* @param service Retrofit service class
* @param <T> Retrofit service 类型
* @return Retrofit service
*/
@NonNull
<T> T createRetrofitService(@NonNull Class<T> service);
/**
* 根据传入的 Class 创建对应的 RxCache service
*
* @param cache RxCache service class
* @param <T> RxCache service 类型
* @return RxCache service
*/
@NonNull
<T> T createCacheService(@NonNull Class<T> cache);
/**
* 清理所有缓存
*/
void clearAllCache();
/**
* 获取 {@link Context}
*
* @return {@link Context}
*/
@NonNull
Context getContext();
}
| [
"[email protected]"
] | |
cd551dd7847dfdd2894cdd953fce61476cf63514 | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/2/2_ca4c0390e83a32c751d27a50b19de6a7e426f79e/ColopediaPanel/2_ca4c0390e83a32c751d27a50b19de6a7e426f79e_ColopediaPanel_t.java | b9a5c25a4920df2e5042684e5587e2714818c25d | [] | 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 | 59,492 | java | /**
* Copyright (C) 2002-2007 The FreeCol Team
*
* This file is part of FreeCol.
*
* FreeCol 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.
*
* FreeCol 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 FreeCol. If not, see <http://www.gnu.org/licenses/>.
*/
package net.sf.freecol.client.gui.panel;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextPane;
import javax.swing.JTree;
import javax.swing.SwingConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.text.BadLocationException;
import javax.swing.text.StyledDocument;
import javax.swing.text.StyleConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import net.sf.freecol.client.gui.Canvas;
import net.sf.freecol.client.gui.i18n.Messages;
import net.sf.freecol.common.Specification;
import net.sf.freecol.common.model.Ability;
import net.sf.freecol.common.model.AbstractGoods;
import net.sf.freecol.common.model.AbstractUnit;
import net.sf.freecol.common.model.BuildableType;
import net.sf.freecol.common.model.BuildingType;
import net.sf.freecol.common.model.Europe;
import net.sf.freecol.common.model.EuropeanNationType;
import net.sf.freecol.common.model.FoundingFather;
import net.sf.freecol.common.model.FoundingFather.FoundingFatherType;
import net.sf.freecol.common.model.FreeColGameObjectType;
import net.sf.freecol.common.model.Goods;
import net.sf.freecol.common.model.GoodsType;
import net.sf.freecol.common.model.IndianNationType;
import net.sf.freecol.common.model.Modifier;
import net.sf.freecol.common.model.Nation;
import net.sf.freecol.common.model.NationType;
import net.sf.freecol.common.model.Player;
import net.sf.freecol.common.model.ResourceType;
import net.sf.freecol.common.model.Scope;
import net.sf.freecol.common.model.TileImprovementType;
import net.sf.freecol.common.model.TileType;
import net.sf.freecol.common.model.Unit.Role;
import net.sf.freecol.common.model.UnitType;
import net.sf.freecol.common.resources.ResourceManager;
import net.sf.freecol.common.util.RandomChoice;
import net.sf.freecol.common.util.Utils;
import net.miginfocom.swing.MigLayout;
/**
* This panel displays the Colopedia.
*/
public final class ColopediaPanel extends FreeColPanel implements TreeSelectionListener {
private static final Logger logger = Logger.getLogger(ColopediaPanel.class.getName());
public static enum PanelType { TERRAIN, RESOURCES, UNITS, GOODS,
SKILLS, BUILDINGS, FATHERS, NATIONS, NATION_TYPES }
private static final Font arrowFont = new Font("Dialog", Font.BOLD, 24);
private static final DecimalFormat modifierFormat =
new DecimalFormat("0.##");
private static final String ROOT = "ROOT";
private final String none;
// layout of production modifier panel
private static final int MODIFIERS_PER_ROW = 5;
private final Canvas parent;
private JLabel header;
private JPanel listPanel;
private JPanel detailPanel;
private JTree tree;
/**
* The constructor that will add the items to this panel.
*
* @param parent The parent of this panel.
*/
public ColopediaPanel(Canvas parent) {
super(parent, new FlowLayout(FlowLayout.CENTER, 1000, 10));
this.parent = parent;
none = Messages.message("none");
setLayout(new BorderLayout());
header = getDefaultHeader(Messages.message("menuBar.colopedia"));
add(header, BorderLayout.NORTH);
listPanel = new JPanel();
listPanel.setOpaque(false);
JScrollPane sl = new JScrollPane(listPanel,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
sl.getVerticalScrollBar().setUnitIncrement(16);
sl.getViewport().setOpaque(false);
add(sl, BorderLayout.WEST);
detailPanel = new JPanel();
detailPanel.setOpaque(false);
detailPanel.setBorder(new EmptyBorder(20, 20, 20, 20));
add(detailPanel, BorderLayout.CENTER);
add(okButton, BorderLayout.SOUTH);
setSize(getPreferredSize());
}
@Override
public Dimension getMinimumSize() {
return new Dimension(850, 600);
}
@Override
public Dimension getPreferredSize() {
return new Dimension(850, parent.getHeight() - 100);
}
/**
* Prepares this panel to be displayed.
*
* @param type - the panel type
*/
public void initialize(PanelType type) {
initialize(type, null);
}
/**
* Prepares this panel to be displayed.
*
* @param panelType - the panel type
* @param type - the FreeColGameObjectType of the item to be displayed
*/
public void initialize(PanelType panelType, FreeColGameObjectType type) {
listPanel.removeAll();
detailPanel.removeAll();
tree = buildTree();
tree.expandRow(panelType.ordinal());
selectDetail(panelType, type);
detailPanel.validate();
}
public void initialize(FreeColGameObjectType type) {
listPanel.removeAll();
detailPanel.removeAll();
tree = buildTree();
if (type instanceof TileType) {
tree.expandRow(PanelType.TERRAIN.ordinal());
buildTerrainDetail((TileType) type);
} else if (type instanceof ResourceType) {
tree.expandRow(PanelType.RESOURCES.ordinal());
buildResourceDetail((ResourceType) type);
} else if (type instanceof UnitType) {
if (((UnitType) type).hasSkill()) {
tree.expandRow(PanelType.SKILLS.ordinal());
} else {
tree.expandRow(PanelType.UNITS.ordinal());
}
buildUnitDetail((UnitType) type);
} else if (type instanceof GoodsType) {
tree.expandRow(PanelType.GOODS.ordinal());
buildGoodsDetail((GoodsType) type);
} else if (type instanceof BuildingType) {
tree.expandRow(PanelType.BUILDINGS.ordinal());
buildBuildingDetail((BuildingType) type);
} else if (type instanceof FoundingFather) {
tree.expandRow(PanelType.FATHERS.ordinal());
buildFatherDetail((FoundingFather) type);
} else if (type instanceof Nation) {
tree.expandRow(PanelType.NATIONS.ordinal());
buildNationDetail((Nation) type);
} else if (type instanceof NationType) {
tree.expandRow(PanelType.NATION_TYPES.ordinal());
buildNationTypeDetail((NationType) type);
}
detailPanel.validate();
}
public void selectDetail(PanelType panelType, FreeColGameObjectType type) {
switch (panelType) {
case TERRAIN:
buildTerrainDetail((TileType) type);
break;
case RESOURCES:
buildResourceDetail((ResourceType) type);
break;
case UNITS:
case SKILLS:
buildUnitDetail((UnitType) type);
break;
case GOODS:
buildGoodsDetail((GoodsType) type);
break;
case BUILDINGS:
buildBuildingDetail((BuildingType) type);
break;
case FATHERS:
buildFatherDetail((FoundingFather) type);
break;
case NATIONS:
buildNationDetail((Nation) type);
break;
case NATION_TYPES:
buildNationTypeDetail((NationType) type);
break;
default:
break;
}
}
/**
* Builds the JTree which represents the navigation menu and then returns it
*
* @return The navigation tree.
*/
private JTree buildTree() {
DefaultMutableTreeNode root;
root = new DefaultMutableTreeNode(new ColopediaTreeItem(null, Messages.message("menuBar.colopedia")));
DefaultMutableTreeNode terrain;
terrain = new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.TERRAIN,
Messages.message("menuBar.colopedia.terrain")));
buildTerrainSubtree(terrain);
root.add(terrain);
DefaultMutableTreeNode resource;
resource = new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.RESOURCES,
Messages.message("menuBar.colopedia.resource")));
buildResourceSubtree(resource);
root.add(resource);
DefaultMutableTreeNode units =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.UNITS,
Messages.message("menuBar.colopedia.unit")));
buildUnitSubtree(units);
root.add(units);
DefaultMutableTreeNode goods =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.GOODS,
Messages.message("menuBar.colopedia.goods")));
buildGoodsSubtree(goods);
root.add(goods);
DefaultMutableTreeNode skills =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.SKILLS,
Messages.message("menuBar.colopedia.skill")));
buildSkillsSubtree(skills);
root.add(skills);
DefaultMutableTreeNode buildings =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.BUILDINGS,
Messages.message("menuBar.colopedia.building")));
buildBuildingSubtree(buildings);
root.add(buildings);
DefaultMutableTreeNode fathers =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.FATHERS,
Messages.message("menuBar.colopedia.father")));
buildFathersSubtree(fathers);
root.add(fathers);
DefaultMutableTreeNode nations =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.NATIONS,
Messages.message("menuBar.colopedia.nation")));
buildNationsSubtree(nations);
root.add(nations);
DefaultMutableTreeNode nationTypes =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.NATION_TYPES,
Messages.message("menuBar.colopedia.nationType")));
buildNationTypesSubtree(nationTypes);
root.add(nationTypes);
DefaultTreeModel treeModel = new DefaultTreeModel(root);
tree = new JTree(treeModel) {
@Override
public Dimension getPreferredSize() {
return new Dimension(200, super.getPreferredSize().height);
}
};
tree.setRootVisible(false);
tree.setCellRenderer(new ColopediaTreeCellRenderer());
tree.setOpaque(false);
tree.addTreeSelectionListener(this);
listPanel.setLayout(new GridLayout(0, 1));
listPanel.add(tree);
return tree;
}
/**
* Builds the buttons for all the tiles.
* @param parent
*/
private void buildTerrainSubtree(DefaultMutableTreeNode parent) {
for (TileType t : Specification.getSpecification().getTileTypeList()) {
buildTerrainItem(t, parent);
}
}
/**
* Builds the buttons for all the resources.
* @param parent
*/
private void buildResourceSubtree(DefaultMutableTreeNode parent) {
for (ResourceType r : Specification.getSpecification().getResourceTypeList()) {
buildResourceItem(r, parent);
}
}
/**
* Builds the buttons for all the units.
* @param parent
*/
private void buildUnitSubtree(DefaultMutableTreeNode parent) {
for (UnitType u : Specification.getSpecification().getUnitTypeList()) {
if (u.getSkill() <= 0 ||
u.hasAbility("model.ability.expertSoldier")) {
buildUnitItem(u, 0.5f, parent);
}
}
}
/**
* Builds the buttons for all the goods.
* @param parent
*/
private void buildGoodsSubtree(DefaultMutableTreeNode parent) {
for (GoodsType g : Specification.getSpecification().getGoodsTypeList()) {
buildGoodsItem(g, parent);
}
}
/**
* Builds the buttons for all the skills.
* @param parent
*/
private void buildSkillsSubtree(DefaultMutableTreeNode parent) {
for (UnitType u : Specification.getSpecification().getUnitTypeList()) {
if (u.getSkill() > 0) {
buildUnitItem(u, 0.5f, parent);
}
}
}
/**
* Builds the buttons for all the buildings.
* @param parent
*/
private void buildBuildingSubtree(DefaultMutableTreeNode parent) {
Image buildingImage = ResourceManager.getImage("Colopedia.buildingSection.image");
ImageIcon buildingIcon = new ImageIcon((buildingImage != null) ? buildingImage : null);
List<BuildingType> buildingTypes = new ArrayList<BuildingType>();
Map<BuildingType, DefaultMutableTreeNode> buildingHash =
new HashMap<BuildingType, DefaultMutableTreeNode>();
for (BuildingType buildingType : Specification.getSpecification().getBuildingTypeList()) {
if (buildingType.getUpgradesFrom() == null) {
DefaultMutableTreeNode item =
new DefaultMutableTreeNode(new ColopediaTreeItem(buildingType,
buildingType.getName(),
buildingIcon));
buildingHash.put(buildingType, item);
parent.add(item);
} else {
buildingTypes.add(buildingType);
}
}
while (!buildingTypes.isEmpty()) {
for (Iterator<BuildingType> iterator = buildingTypes.iterator(); iterator.hasNext();) {
BuildingType buildingType = iterator.next();
DefaultMutableTreeNode node = buildingHash.get(buildingType.getUpgradesFrom());
if (node != null) {
DefaultMutableTreeNode item =
new DefaultMutableTreeNode(new ColopediaTreeItem(buildingType,
buildingType.getName(),
buildingIcon));
node.add(item);
buildingHash.put(buildingType, item);
iterator.remove();
}
}
}
}
/**
* Builds the buttons for all the founding fathers.
* @param parent
*/
private void buildFathersSubtree(DefaultMutableTreeNode parent) {
EnumMap<FoundingFatherType, List<FoundingFather>> fathersByType =
new EnumMap<FoundingFatherType, List<FoundingFather>>(FoundingFatherType.class);
for (FoundingFatherType fatherType : FoundingFatherType.values()) {
fathersByType.put(fatherType, new ArrayList<FoundingFather>());
}
for (FoundingFather foundingFather : Specification.getSpecification().getFoundingFathers()) {
fathersByType.get(foundingFather.getType()).add(foundingFather);
}
for (FoundingFatherType fatherType : FoundingFatherType.values()) {
DefaultMutableTreeNode node =
new DefaultMutableTreeNode(new ColopediaTreeItem(PanelType.FATHERS,
FoundingFather.getTypeAsString(fatherType)));
parent.add(node);
for (FoundingFather father : fathersByType.get(fatherType)) {
buildFatherItem(father, node);
}
}
}
/**
* Builds the buttons for all the nations.
* @param parent
*/
private void buildNationsSubtree(DefaultMutableTreeNode parent) {
for (Nation type : Specification.getSpecification().getEuropeanNations()) {
buildNationItem(type, parent);
}
for (Nation type : Specification.getSpecification().getIndianNations()) {
buildNationItem(type, parent);
}
}
/**
* Builds the buttons for all the nation types.
* @param parent
*/
private void buildNationTypesSubtree(DefaultMutableTreeNode parent) {
List<NationType> nations = new ArrayList<NationType>();
nations.addAll(Specification.getSpecification().getEuropeanNationTypes());
nations.addAll(Specification.getSpecification().getREFNationTypes());
nations.addAll(Specification.getSpecification().getIndianNationTypes());
for (NationType type : nations) {
buildNationTypeItem(type, parent);
}
}
/**
* Builds the button for the given tile.
*
* @param tileType - the TileType
* @param parent - the parent node
*/
private void buildTerrainItem(TileType tileType, DefaultMutableTreeNode parent) {
ImageIcon icon = new ImageIcon(getLibrary().getScaledTerrainImage(tileType, 0.25f));
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(tileType,
tileType.getName(), icon));
parent.add(item);
}
/**
* Builds the button for the given resource.
*
* @param resType - the ResourceType
* @param parent - the parent node
*/
private void buildResourceItem(ResourceType resType, DefaultMutableTreeNode parent) {
ImageIcon icon = getLibrary().getScaledBonusImageIcon(resType, 0.75f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(resType,
resType.getName(),
icon));
parent.add(item);
}
/**
* Builds the button for the given unit.
*
* @param unitType
* @param scale
* @param parent
*/
private void buildUnitItem(UnitType unitType, float scale, DefaultMutableTreeNode parent) {
ImageIcon icon = getLibrary().getScaledImageIcon(getLibrary().getUnitImageIcon(unitType), 0.5f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(unitType,
unitType.getName(), icon));
parent.add(item);
}
/**
* Builds the button for the given goods.
*
* @param goodsType The GoodsType
* @param parent The parent tree node
*/
private void buildGoodsItem(GoodsType goodsType, DefaultMutableTreeNode parent) {
ImageIcon icon = getLibrary().getScaledGoodsImageIcon(goodsType, 0.75f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(goodsType,
goodsType.getName(), icon));
parent.add(item);
}
/**
* Builds the button for the given founding father.
*
* @param foundingFather
* @param parent
*/
private void buildFatherItem(FoundingFather foundingFather, DefaultMutableTreeNode parent) {
String name = foundingFather.getName();
ImageIcon icon = getLibrary().getScaledGoodsImageIcon(Goods.BELLS, 0.75f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(foundingFather,
name, icon));
parent.add(item);
}
/**
* Builds the button for the given nation.
*
* @param nation
* @param parent
*/
private void buildNationItem(Nation nation, DefaultMutableTreeNode parent) {
String name = nation.getName();
ImageIcon icon = getLibrary().getScaledImageIcon(getLibrary().getCoatOfArmsImageIcon(nation), 0.5f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(nation,
name, icon));
parent.add(item);
}
/**
* Builds the button for the given nation type.
*
* @param nationType
* @param parent
*/
private void buildNationTypeItem(NationType nationType, DefaultMutableTreeNode parent) {
String name = nationType.getName();
//ImageIcon icon = getLibrary().getCoatOfArmsImageIcon(nation);
ImageIcon icon = getLibrary().getScaledGoodsImageIcon(Goods.BELLS, 0.75f);
DefaultMutableTreeNode item = new DefaultMutableTreeNode(new ColopediaTreeItem(nationType,
name, icon));
parent.add(item);
}
private JButton getButton(FreeColGameObjectType type, String text, ImageIcon icon) {
JButton button = getLinkButton(text == null ? type.getName() : text, icon, type.getId());
button.addActionListener(this);
return button;
}
private JButton getButton(FreeColGameObjectType type) {
return getButton(type, null, null);
}
private JButton getResourceButton(final ResourceType resourceType) {
return getButton(resourceType, null, getLibrary().getBonusImageIcon(resourceType));
}
private JButton getGoodsButton(final GoodsType goodsType) {
return getButton(goodsType, null, getLibrary().getGoodsImageIcon(goodsType));
}
private JButton getGoodsButton(final GoodsType goodsType, String text) {
return getButton(goodsType, text, getLibrary().getGoodsImageIcon(goodsType));
}
private JButton getGoodsButton(final GoodsType goodsType, int amount) {
return getButton(goodsType, Integer.toString(amount), getLibrary().getGoodsImageIcon(goodsType));
}
private JButton getUnitButton(final UnitType unitType, Role role) {
ImageIcon unitIcon = getLibrary().scaleIcon(getLibrary().getUnitImageIcon(unitType, role), 0.66f);
JButton unitButton = getButton(unitType, null, unitIcon);
unitButton.setHorizontalAlignment(SwingConstants.LEFT);
return unitButton;
}
private JButton getUnitButton(final UnitType unitType) {
return getUnitButton(unitType, Role.DEFAULT);
}
/**
* Builds the details panel for the given tile.
*
* @param tileType The TileType
*/
private void buildTerrainDetail(TileType tileType) {
detailPanel.removeAll();
if (tileType == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 4, fillx, gap 20", "[][]push[][]", ""));
String movementCost = String.valueOf(tileType.getBasicMoveCost() / 3);
String defenseBonus = none;
Set<Modifier> defenceModifiers = tileType.getDefenceBonus();
if (!defenceModifiers.isEmpty()) {
defenseBonus = getModifierAsString(defenceModifiers.iterator().next());
}
GoodsType secondaryGoodsType = tileType.getSecondaryGoods();
JLabel nameLabel = new JLabel(tileType.getName());
nameLabel.setFont(smallHeaderFont);
detailPanel.add(nameLabel, "span, align center");
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.terrainImage")));
Image terrainImage = getLibrary().getScaledTerrainImage(tileType, 1f);
detailPanel.add(new JLabel(new ImageIcon(terrainImage)));
List<ResourceType> resourceList = tileType.getResourceTypeList();
if (resourceList.size() > 0) {
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.resource")));
if (resourceList.size() > 1) {
detailPanel.add(getResourceButton(resourceList.get(0)), "split " + resourceList.size());
for (int index = 1; index < resourceList.size(); index++) {
detailPanel.add(getResourceButton(resourceList.get(index)));
}
} else {
detailPanel.add(getResourceButton(resourceList.get(0)));
}
} else {
detailPanel.add(new JLabel(), "wrap");
}
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.movementCost")));
detailPanel.add(new JLabel(movementCost));
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.defenseBonus")));
detailPanel.add(new JLabel(defenseBonus));
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.production")));
List<AbstractGoods> production = tileType.getProduction();
if (production.size() > 0) {
AbstractGoods goods = production.get(0);
if (production.size() > 1) {
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()),
"span, split " + production.size());
for (int index = 1; index < production.size(); index++) {
goods = production.get(index);
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()));
}
} else {
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()), "span");
}
} else {
detailPanel.add(new JLabel(), "wrap");
}
detailPanel.add(new JLabel(Messages.message("colopedia.terrain.description")));
detailPanel.add(getDefaultTextArea(tileType.getDescription()), "span, growx");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given resource.
*
* @param type The ResourceType
*/
private void buildResourceDetail(ResourceType type) {
detailPanel.removeAll();
if (type == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 2, fillx, gapx 20", "", ""));
JLabel name = new JLabel(type.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
Set<Modifier> modifiers = type.getFeatureContainer().getModifiers();
detailPanel.add(new JLabel(Messages.message("colopedia.resource.bonusProduction")));
JPanel goodsPanel = new JPanel();
goodsPanel.setOpaque(false);
for (Modifier modifier : modifiers) {
String text = getModifierAsString(modifier);
if (modifier.hasScope()) {
List<String> scopeStrings = new ArrayList<String>();
for (Scope scope : modifier.getScopes()) {
if (scope.getType() != null) {
FreeColGameObjectType objectType = Specification.getSpecification()
.getType(scope.getType());
scopeStrings.add(objectType.getName());
}
}
if (!scopeStrings.isEmpty()) {
text += " (" + Utils.join(", ", scopeStrings) + ")";
}
}
GoodsType goodsType = Specification.getSpecification().getGoodsType(modifier.getId());
JButton goodsButton = getGoodsButton(goodsType, text);
goodsPanel.add(goodsButton);
}
detailPanel.add(goodsPanel);
detailPanel.add(new JLabel(Messages.message("colopedia.resource.description")), "newline 20");
detailPanel.add(getDefaultTextArea(type.getDescription()), "growx");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given unit.
*
* @param type - the UnitType
*/
private void buildUnitDetail(UnitType type) {
detailPanel.removeAll();
if (type == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 2, fillx, gapx 20", "", ""));
JLabel name = new JLabel(type.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
detailPanel.add(new JLabel(Messages.message("colopedia.unit.offensivePower")));
detailPanel.add(new JLabel(Integer.toString(type.getOffence())));
detailPanel.add(new JLabel(Messages.message("colopedia.unit.defensivePower")));
detailPanel.add(new JLabel(Integer.toString(type.getDefence())));
detailPanel.add(new JLabel(Messages.message("colopedia.unit.movement")));
detailPanel.add(new JLabel(String.valueOf(type.getMovement()/3)));
if (type.canCarryGoods() || type.canCarryUnits()) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.capacity")));
detailPanel.add(new JLabel(Integer.toString(type.getSpace())));
}
if (type.hasSkill()) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.skill")));
detailPanel.add(new JLabel(Integer.toString(type.getSkill())));
List<BuildingType> schools = new ArrayList<BuildingType>();
for (final BuildingType buildingType : Specification.getSpecification().getBuildingTypeList()) {
if (buildingType.hasAbility("model.ability.teach") &&
buildingType.canAdd(type)) {
schools.add(buildingType);
}
}
if (!schools.isEmpty()) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.school")));
if (schools.size() > 1) {
detailPanel.add(getButton(schools.get(0)),
"span, split " + schools.size());
for (int index = 1; index < schools.size(); index++) {
detailPanel.add(getButton(schools.get(index)));
}
} else {
detailPanel.add(getButton(schools.get(0)));
}
}
}
Player player = getMyPlayer();
// player can be null when using the map editor
Europe europe = (player == null) ? null : player.getEurope();
String price = null;
if (europe != null && europe.getUnitPrice(type) > 0) {
price = Integer.toString(europe.getUnitPrice(type));
} else if (type.getPrice() > 0) {
price = Integer.toString(type.getPrice());
}
if (price != null) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.price")));
detailPanel.add(new JLabel(price));
}
// Requires - prerequisites to build
if (!type.getAbilitiesRequired().isEmpty()) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.requirements")), "top");
try {
JTextPane textPane = getDefaultTextPane();
StyledDocument doc = textPane.getStyledDocument();
appendRequiredAbilities(doc, type);
detailPanel.add(textPane);
} catch(BadLocationException e) {
logger.warning(e.toString());
}
}
List<Modifier> bonusList = new ArrayList<Modifier>();
for (GoodsType goodsType : Specification.getSpecification().getGoodsTypeList()) {
bonusList.addAll(type.getModifierSet(goodsType.getId()));
}
int bonusNumber = bonusList.size();
if (bonusNumber > 0) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.productionBonus")),
"newline 20, top");
/*
int rows = bonusNumber / MODIFIERS_PER_ROW;
if (bonusNumber % MODIFIERS_PER_ROW != 0) {
rows++;
}
*/
JPanel productionPanel = new JPanel(new GridLayout(0, MODIFIERS_PER_ROW));
productionPanel.setOpaque(false);
for (Modifier productionBonus : bonusList) {
GoodsType goodsType = Specification.getSpecification().getGoodsType(productionBonus.getId());
String bonus = getModifierAsString(productionBonus);
productionPanel.add(getGoodsButton(goodsType, bonus));
}
detailPanel.add(productionPanel, "growx");
}
if (!type.getGoodsRequired().isEmpty()) {
detailPanel.add(new JLabel(Messages.message("colopedia.unit.goodsRequired")),
"newline 20");
AbstractGoods goods = type.getGoodsRequired().get(0);
if (type.getGoodsRequired().size() > 1) {
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()),
"span, split " + type.getGoodsRequired().size());
for (int index = 1; index < type.getGoodsRequired().size(); index++) {
goods = type.getGoodsRequired().get(index);
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()));
}
} else {
detailPanel.add(getGoodsButton(goods.getType(), goods.getAmount()));
}
}
detailPanel.add(new JLabel(Messages.message("colopedia.unit.description")),
"newline 20");
detailPanel.add(getDefaultTextArea(type.getDescription()), "growx");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given goods.
*
* @param type The GoodsType
*/
private void buildGoodsDetail(GoodsType type) {
detailPanel.removeAll();
if (type == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 2, fillx, gap 20", "", ""));
JLabel name = new JLabel(type.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
detailPanel.add(new JLabel(Messages.message("colopedia.goods.isFarmed")));
detailPanel.add(new JLabel(Messages.message(type.isFarmed() ? "yes" : "no")));
if (type.isFarmed()) {
List<TileImprovementType> improvements = new ArrayList<TileImprovementType>();
List<Modifier> modifiers = new ArrayList<Modifier>();
for (TileImprovementType improvementType :
Specification.getSpecification().getTileImprovementTypeList()) {
Modifier productionModifier = improvementType.getProductionModifier(type);
if (productionModifier != null) {
improvements.add(improvementType);
modifiers.add(productionModifier);
}
}
detailPanel.add(new JLabel(Messages.message("colopedia.goods.improvedBy")), "top");
if (improvements.size() == 0) {
detailPanel.add(new JLabel(none));
} else if (improvements.size() == 1) {
detailPanel.add(new JLabel(improvements.get(0).getName() + " (" +
getModifierAsString(modifiers.get(0)) + ")"));
} else {
detailPanel.add(new JLabel(improvements.get(0).getName() + " (" +
getModifierAsString(modifiers.get(0)) + ")"),
"flowy, split " + improvements.size());
for (int index = 1; index < improvements.size(); index++) {
detailPanel.add(new JLabel(improvements.get(index).getName() + " (" +
getModifierAsString(modifiers.get(index)) + ")"));
}
}
} else {
detailPanel.add(new JLabel(Messages.message("colopedia.goods.madeFrom")));
if (type.isRefined()) {
detailPanel.add(getGoodsButton(type.getRawMaterial()));
} else {
detailPanel.add(new JLabel(none));
}
}
detailPanel.add(new JLabel(Messages.message("colopedia.goods.makes")));
if (type.isRawMaterial()) {
detailPanel.add(getGoodsButton(type.getProducedMaterial()), "wrap 40");
} else {
detailPanel.add(new JLabel(none), "wrap 40");
}
detailPanel.add(new JLabel(Messages.message("colopedia.goods.description")));
detailPanel.add(getDefaultTextArea(type.getDescription()), "growx");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given building.
*
* @param buildingType The BuildingType
*/
private void buildBuildingDetail(BuildingType buildingType) {
/*
* don't need this at the moment int[][] buildingUpkeep = { {0, -1, -1}, //
* Town hall {0, 10, -1}, // Carpenter's house, Lumber mill {0, 5, 15}, //
* Blacksmith's house, Blacksmith's shop, Iron works {0, 5, 15}, //
* Tobacconist's house, Tobacconist's shop, Cigar factory {0, 5, 15}, //
* Weaver's house, Weaver's shop, Textile mill {0, 5, 15}, //
* Distiller's house, Rum distillery, Rum factory {0, 5, 15}, // Fur
* trader's house, Fur trading post, Fur factory {5, 10, 15}, //
* Schoolhouse, College, University {5, 10, 15}, // Armory, Magazine,
* Arsenal {5, 15, -1}, // Church, Cathedral {0, 10, 15}, // Stockade,
* Fort, Fortress {5, 5, -1}, // Warehouse, Warehouse expansion {5, -1,
* -1}, // Stables {5, 10, 15}, // Docks, Drydock, Shipyard {5, 10, -1}, //
* Printing press, Newspaper {15, -1, -1} // Custom house };
*/
detailPanel.removeAll();
if (buildingType == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 2, fillx, gapx 20", "", ""));
JLabel name = new JLabel(buildingType.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
// Requires - prerequisites to build
JTextPane textPane = getDefaultTextPane();
StyledDocument doc = textPane.getStyledDocument();
try {
if (buildingType.getUpgradesFrom() != null) {
StyleConstants.setComponent(doc.getStyle("button"), getButton(buildingType.getUpgradesFrom()));
doc.insertString(doc.getLength(), " ", doc.getStyle("button"));
doc.insertString(doc.getLength(), "\n", doc.getStyle("regular"));
}
if (buildingType.getPopulationRequired() > 0) {
doc.insertString(doc.getLength(),
String.valueOf(buildingType.getPopulationRequired()) + " " +
Messages.message("colonists") + "\n",
doc.getStyle("regular"));
}
appendRequiredAbilities(doc, buildingType);
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.requires")), "top");
detailPanel.add(textPane, "growx");
} catch(BadLocationException e) {
logger.warning(e.toString());
}
// Costs to build - Hammers & Tools
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.cost")));
if (buildingType.getGoodsRequired().isEmpty()) {
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.autoBuilt")));
} else {
AbstractGoods goodsRequired = buildingType.getGoodsRequired().get(0);
if (buildingType.getGoodsRequired().size() > 1) {
detailPanel.add(getGoodsButton(goodsRequired.getType(), goodsRequired.getAmount()),
"split " + buildingType.getGoodsRequired().size());
for (int index = 1; index < buildingType.getGoodsRequired().size(); index++) {
goodsRequired = buildingType.getGoodsRequired().get(index);
detailPanel.add(getGoodsButton(goodsRequired.getType(), goodsRequired.getAmount()));
}
} else {
detailPanel.add((getGoodsButton(goodsRequired.getType(), goodsRequired.getAmount())));
}
}
// Production - Needs & Produces
if (buildingType.hasAbility("model.ability.teach")) {
JPanel production = new JPanel();
production.setOpaque(false);
production.setLayout(new MigLayout("wrap 3, gapx 20", "", ""));
for (UnitType unitType2 : Specification.getSpecification().getUnitTypeList()) {
if (buildingType.canAdd(unitType2)) {
production.add(getButton(unitType2));
}
}
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.teaches")), "top");
detailPanel.add(production);
} else {
GoodsType inputType = buildingType.getConsumedGoodsType();
GoodsType outputType = buildingType.getProducedGoodsType();
if (outputType != null) {
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.production")));
if (inputType != null) {
detailPanel.add(getGoodsButton(inputType), "split 3");
JLabel arrow = new JLabel("\u2192");
arrow.setFont(arrowFont);
detailPanel.add(arrow);
}
detailPanel.add(getGoodsButton(outputType));
}
}
int workplaces = buildingType.getWorkPlaces();
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.workplaces")));
detailPanel.add(new JLabel(Integer.toString(workplaces)));
// Specialist
if (workplaces > 0) {
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.specialist")));
final UnitType unitType = Specification.getSpecification()
.getExpertForProducing(buildingType.getProducedGoodsType());
if (unitType == null) {
detailPanel.add(new JLabel(none));
} else {
detailPanel.add(getUnitButton(unitType));
}
}
Set<Modifier> bonusList = buildingType.getFeatureContainer().getModifiers();
int bonusNumber = bonusList.size();
if (bonusNumber > 0) {
JPanel productionPanel = new JPanel();
productionPanel.setOpaque(false);
for (Modifier productionBonus : bonusList) {
try {
GoodsType goodsType = Specification.getSpecification()
.getGoodsType(productionBonus.getId());
String bonus = getModifierAsString(productionBonus);
productionPanel.add(getGoodsButton(goodsType, bonus));
} catch(Exception e) {
// not a production bonus
String bonus = productionBonus.getName()
+ ": " + getModifierAsString(productionBonus);
productionPanel.add(new JLabel(bonus));
}
}
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.modifiers")), "top");
detailPanel.add(productionPanel);
}
// Notes
detailPanel.add(new JLabel(Messages.message("colopedia.buildings.notes")), "newline 20, top");
detailPanel.add(getDefaultTextArea(buildingType.getDescription()), "growx");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given founding father.
*
* @param father - the FoundingFather
*/
private void buildFatherDetail(FoundingFather father) {
detailPanel.removeAll();
if (father == null) {
return;
}
detailPanel.setLayout(new MigLayout("wrap 2, fillx, gapx 20", "", ""));
JLabel name = new JLabel(father.getName() + " (" + father.getTypeAsString() + ")");
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
Image image = getLibrary().getFoundingFatherImage(father);
JLabel imageLabel;
if (image != null) {
imageLabel = new JLabel(new ImageIcon(image));
} else {
imageLabel = new JLabel();
}
detailPanel.add(imageLabel, "top");
String text = Messages.message(father.getDescription()) + "\n\n" + "["
+ Messages.message(father.getBirthAndDeath()) + "] "
+ Messages.message(father.getText());
JTextArea description = getDefaultTextArea(text);
detailPanel.add(description, "top, growx, shrink");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given nation.
*
* @param nation - the Nation
*/
private void buildNationDetail(Nation nation) {
detailPanel.removeAll();
if (nation == null) {
return;
}
NationType currentNationType = nation.getType();;
for (Player player : getGame().getPlayers()) {
if (player.getNation() == nation) {
currentNationType = player.getNationType();
break;
}
}
detailPanel.setLayout(new MigLayout("wrap 3, fillx, gapx 20", "", ""));
JLabel name = new JLabel(nation.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
JLabel artLabel = new JLabel(getLibrary().getMonarchImageIcon(nation));
detailPanel.add(artLabel, "spany, gap 40, top");
detailPanel.add(new JLabel(Messages.message("colopedia.nation.ruler")));
detailPanel.add(new JLabel(nation.getRulerName()));
detailPanel.add(new JLabel(Messages.message("colopedia.nation.defaultAdvantage")));
detailPanel.add(getButton(nation.getType()));
detailPanel.add(new JLabel(Messages.message("colopedia.nation.currentAdvantage")));
detailPanel.add(getButton(currentNationType), "wrap push");
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given nation type.
*
* @param nationType - the NationType
*/
private void buildNationTypeDetail(NationType nationType) {
if (nationType instanceof EuropeanNationType) {
buildEuropeanNationTypeDetail((EuropeanNationType) nationType);
} else if (nationType instanceof IndianNationType) {
buildIndianNationTypeDetail((IndianNationType) nationType);
}
}
/**
* Builds the details panel for the given nation type.
*
* @param nationType - the EuropeanNationType
*/
private void buildEuropeanNationTypeDetail(EuropeanNationType nationType) {
detailPanel.removeAll();
if (nationType == null) {
return;
}
Set<Ability> abilities = nationType.getFeatureContainer().getAbilities();
Set<Modifier> modifiers = nationType.getFeatureContainer().getModifiers();
detailPanel.setLayout(new MigLayout("wrap 2, gapx 20", "", ""));
JLabel name = new JLabel(nationType.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.units")));
List<AbstractUnit> startingUnits = nationType.getStartingUnits();
if (startingUnits.isEmpty()) {
detailPanel.add(new JLabel());
} else {
AbstractUnit startingUnit = startingUnits.get(0);
if (startingUnits.size() > 1) {
detailPanel.add(getUnitButton(startingUnit.getUnitType(), startingUnit.getRole()),
"span, split " + startingUnits.size());
for (int index = 1; index < startingUnits.size(); index++) {
startingUnit = startingUnits.get(index);
detailPanel.add(getUnitButton(startingUnit.getUnitType(), startingUnit.getRole()));
}
} else {
detailPanel.add(getUnitButton(startingUnit.getUnitType(), startingUnit.getRole()));
}
}
if (!abilities.isEmpty()) {
detailPanel.add(new JLabel(Messages.message("abilities")), "newline 20, span");
String trueString = Messages.message("true");
String falseString = Messages.message("false");
for (Ability ability : abilities) {
detailPanel.add(new JLabel("* " + ability.getName()));
String value = ability.getValue() ? trueString : falseString;
detailPanel.add(new JLabel(value));
}
}
if (!modifiers.isEmpty()) {
detailPanel.add(new JLabel(Messages.message("modifiers")), "newline 20, span");
for (Modifier modifier : modifiers) {
detailPanel.add(new JLabel("* " + modifier.getName()));
detailPanel.add(new JLabel(getModifierAsString(modifier)));
}
}
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* Builds the details panel for the given nation type.
*
* @param nationType - the IndianNationType
*/
private void buildIndianNationTypeDetail(IndianNationType nationType) {
detailPanel.removeAll();
if (nationType == null) {
return;
}
List<RandomChoice<UnitType>> skills = nationType.getSkills();
detailPanel.setLayout(new MigLayout("wrap 2, gapx 20", "", ""));
JLabel name = new JLabel(nationType.getName());
name.setFont(smallHeaderFont);
detailPanel.add(name, "span, align center, wrap 40");
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.aggression")));
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.aggression." +
nationType.getAggression().toString().toLowerCase())));
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.numberOfSettlements")));
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.numberOfSettlements." +
nationType.getNumberOfSettlements().toString()
.toLowerCase())));
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.typeOfSettlements")));
detailPanel.add(new JLabel(nationType.getSettlementTypeAsString(),
new ImageIcon(getLibrary().getSettlementImage(nationType.getTypeOfSettlement())),
SwingConstants.CENTER));
List<String> regionNames = new ArrayList<String>();
for (String regionName : nationType.getRegionNames()) {
regionNames.add(Messages.message(regionName + ".name"));
}
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.regions")));
detailPanel.add(new JLabel(Utils.join(", ", regionNames)));
detailPanel.add(new JLabel(Messages.message("colopedia.nationType.skills")), "top, newline 20");
GridLayout gridLayout = new GridLayout(0, 2);
gridLayout.setHgap(10);
JPanel unitPanel = new JPanel(gridLayout);
unitPanel.setOpaque(false);
for (RandomChoice<UnitType> choice : skills) {
unitPanel.add(getUnitButton(choice.getObject()));
}
detailPanel.add(unitPanel);
detailPanel.revalidate();
detailPanel.repaint();
}
/**
* This function analyses a tree selection event and calls the right methods to take care
* of building the requested unit's details.
*
* @param event The incoming TreeSelectionEvent.
*/
public void valueChanged(TreeSelectionEvent event) {
if (event.getSource() == tree) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)tree.getLastSelectedPathComponent();
DefaultMutableTreeNode parent = node;
while (parent != null) {
ColopediaTreeItem parentItem = (ColopediaTreeItem) parent.getUserObject();
if (parentItem.getPanelType() == null) {
parent = (DefaultMutableTreeNode) parent.getParent();
} else {
ColopediaTreeItem nodeItem = (ColopediaTreeItem) node.getUserObject();
selectDetail(parentItem.getPanelType(), nodeItem.getFreeColGameObjectType());
break;
}
}
}
}
/**
* Returns a text area with standard settings suitable for use in FreeCol
* dialogs.
*
* @param text The text to display in the text area.
* @return a text area with standard settings suitable for use in FreeCol
* dialogs.
*/
public static JTextArea getDefaultTextArea(String text) {
JTextArea textArea = new JTextArea(text);
textArea.setOpaque(false);
textArea.setLineWrap(true);
textArea.setWrapStyleWord(true);
textArea.setFocusable(false);
textArea.setFont(defaultFont);
return textArea;
}
public String getModifierAsString(Modifier modifier) {
String bonus = modifierFormat.format(modifier.getValue());
switch(modifier.getType()) {
case ADDITIVE:
if (modifier.getValue() > 0) {
bonus = "+" + bonus;
}
break;
case PERCENTAGE:
if (modifier.getValue() > 0) {
bonus = "+" + bonus;
}
bonus = bonus + "%";
break;
case MULTIPLICATIVE:
bonus = "\u00D7" + bonus;
break;
default:
}
return bonus;
}
public void appendRequiredAbilities(StyledDocument doc, BuildableType buildableType)
throws BadLocationException {
for (Entry<String, Boolean> entry : buildableType.getAbilitiesRequired().entrySet()) {
doc.insertString(doc.getLength(),
Messages.message(entry.getKey() + ".name"),
doc.getStyle("regular"));
List<JButton> requiredTypes = new ArrayList<JButton>();
for (Ability ability : Specification.getSpecification().getAbilities(entry.getKey())) {
if (ability.getValue() == entry.getValue() &&
ability.getSource() != null) {
JButton typeButton = getButton(ability.getSource());
typeButton.addActionListener(this);
requiredTypes.add(typeButton);
}
}
if (!requiredTypes.isEmpty()) {
doc.insertString(doc.getLength(), " (", doc.getStyle("regular"));
StyleConstants.setComponent(doc.getStyle("button"), requiredTypes.get(0));
doc.insertString(doc.getLength(), " ", doc.getStyle("button"));
for (int index = 1; index < requiredTypes.size(); index++) {
JButton button = requiredTypes.get(index);
doc.insertString(doc.getLength(), " / ", doc.getStyle("regular"));
StyleConstants.setComponent(doc.getStyle("button"), button);
doc.insertString(doc.getLength(), " ", doc.getStyle("button"));
}
doc.insertString(doc.getLength(), ")", doc.getStyle("regular"));
}
doc.insertString(doc.getLength(), "\n", doc.getStyle("regular"));
}
}
/**
* This function analyses an event and calls the right methods to take care
* of the user's requests.
*
* @param event The incoming ActionEvent.
*/
public void actionPerformed(ActionEvent event) {
String command = event.getActionCommand();
if (OK.equals(command)) {
parent.remove(this);
} else {
FreeColGameObjectType type = Specification.getSpecification().getType(command);
initialize(type);
}
}
}
| [
"[email protected]"
] | |
aadc67fb916d1ee7d22c00dcac2bb2f34c233c3a | 411e0c52361f21bb8aa297e3b4f6341f24b018b2 | /2000/Graph/4/Graph3dIldarC2/Piace.java | f3be17820e94938995e0712db4f2350eb8ccbbe7 | [] | no_license | ildar66/myGraph3DI | 47340b5d56ee6d14feac513d5a9377e5700e69d5 | 9165adf92c15aeb8e2e1700e61af2da5afc50a37 | refs/heads/master | 2020-12-02T23:54:19.148533 | 2017-07-01T11:13:10 | 2017-07-01T11:13:10 | 95,959,207 | 0 | 0 | null | null | null | null | WINDOWS-1251 | Java | false | false | 23,957 | java | import java.awt.event.*;
import java.util.*;
import java.awt.*;
public class Piace extends Panel implements MouseListener, MouseMotionListener, KeyListener {
Graph3DI graph;
Vector points3D = new Vector(); //Вектор физических точек(3D).
Vector figures = new Vector(); //Вектор всех фигур апплета.
Figure figure; //Текущая фигура.
Point offset; //Начало отсчета.
Element select; //Текущий элемент.
Side copy; //Используется для сохранения текущей стороны(Side).
Matrix3D matrix = new Matrix3D(); //Для динамики мира точек3D
int tab, x0, y0, kind, step; //tab-для навигации по элементам мира;kind-вид элемента;step-перемещение элемента по осям.(x0,y0)-последняя записанная точка
float turn, turnSum, rotate; //turn-приращение угола поворота,turnSum-угол поворота в reconstruct_A.
int tab_add = 1; //для навигации по элементам.
floatPanel FP; //red? панель инструментов.
boolean full, net, flag_backface; //заполненность, сеть, флаг задней стороны Элементов,
Color color = Color.black; //цвет Элементов.
Rectangle rect = new Rectangle(0, 0, 10, 10); //следует за нажатием мыши.
Image offScreenImage; //для двойной буферизации.
Graphics offScreen; //для двойной буферизации.
public Piace(Graph3DI graph)
{
this.graph = graph;
addMouseMotionListener(this);
addMouseListener(this);
addKeyListener(this);
figures.addElement(figure = new Figure(this, kind, color, full, net, flag_backface));
figure.elements.addElement(select = new Side(this, kind, color, full));
setBackground(Color.white);
rotate = step = 3; //?
FP = new floatPanel(this, "Float Panel"); //red
}
public void mousePressed(MouseEvent e)
{
int x = e.getX(), y = e.getY();
rect.translate(x - rect.x - 5, y - rect.y - 5); //new
Shade.mouseDown(this, x, y);
if (offset == null)
offset = new Point(x, y);
if(select.field.size() == 0)
{SavePoint3D(numberPoint(x, y) , x, y); x0 = x; y0 = y;}
repaint(x-5, y-5, 10, 10);
}
public void mouseDragged(MouseEvent e) //new show Shade.java
{
int x = e.getX(), y = e.getY();
rect.translate(x - rect.x - 5, y - rect.y - 5);
if (((select.kind == Element.freeLine)||(select.kind == Element.freePoly))&&(!(rect.contains(x0, y0))))
{SavePoint3D(numberPoint(x, y) , x, y); x0 = x; y0 = y;}
Shade.mouseDrag(this, x, y);
}
public void mouseReleased(MouseEvent e)
{
int x = e.getX(), y = e.getY();
rect.translate(x - rect.x - 5, y - rect.y - 5); //new
if(!rect.contains(x0, y0)) //new
SavePoint3D(numberPoint(x, y) , x, y);
Rectangle rec = select.getShade(offset, "view Face").getBounds();
repaint(rec.x-5, rec.y-5, rec.width+10, rec.height+10);
Shade.mouseUp(this);
}
public void mouseMoved(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseClicked(MouseEvent e) {}
public void SavePoint3D(int i, int x, int y)
{
select.add(i);
if(i == points3D.size())//если точка новая, то:
{
points3D.addElement(new Point3D(x - offset.x, y - offset.y, 0));//current?
figure.add(i);
}
}
public int numberPoint(int x, int y)
{
rect.translate(x - rect.x - 5, y - rect.y - 5);
if(select instanceof Side)
for (int i = points3D.size()-1; i >= 0 ; i--)
{
x = Math.round(((Point3D)points3D.elementAt(i)).x) + offset.x;
y = Math.round(((Point3D)points3D.elementAt(i)).y) + offset.y;
if (rect.contains(x, y))
return i;
}
return points3D.size();
}
public void message()
{System.out.println("3Dpoints:"+points3D.size()+";sides:"+figure.elements.size()+";select:"+select.field.size()+";figure:"+figure.field.size());}
public void keyTyped(KeyEvent e)
{
char key = e.getKeyChar();
if ((key == 'e')&&(select.field.size() != 0))
{newElement();}
if ((key == 's')&&(select.field.size() != 0))
{newSide(); }
if ((key == 'f')&&(select.field.size() != 0))
{newFigure(); }
if ((key == 'n')&&(select.field.size() != 0))
{next_offset();}
if (key == '+')
{tab_add = 1; rotate = Math.abs(rotate); step = Math.abs(step);}
if (key == '-')
{tab_add = -1; rotate = - Math.abs(rotate); step = -Math.abs(step);}
if (key == '*')
{tab_add = - tab_add; rotate = - rotate; step = - step;}
if ((key == 'c')&&(select.field.size() > 1))
{copy(select);}
if ((key == 'C') && (select.field.size() > 1))
{copy(figure);}
if ((key == 'A')&&(turnSum < 360)&&(select.field.size() != 0))
{reconstruct_A(select);}
if ((key == 'L')&&(select instanceof Side)&&(select.field.size() != 0))
{face((Side)select, false);}
if ((key == 'l')&&(select instanceof Side)&&(select.field.size() != 0))
{face((Side)select, true);}
if (key == 'x')
rotate("X", figure);
if (key == 'y')
rotate("Y", figure);
if (key == 'z')
rotate("Z", figure);
if (key == 'X')
{ matrix.identity(); matrix.rotate(rotate,"X", false);for (int i=0; i<points3D.size(); i++) matrix.transform((Point3D)points3D.elementAt(i));}
if (key == 'Y')
{ matrix.identity(); matrix.rotate(rotate,"Y", false);for (int i=0; i<points3D.size(); i++) matrix.transform((Point3D)points3D.elementAt(i));}
if (key == 'Z')
{ matrix.identity(); matrix.rotate(rotate,"Z", false);for (int i=0; i<points3D.size(); i++) matrix.transform((Point3D)points3D.elementAt(i));}
if (key == '1')
rotate("X", select);
if (key == '2')
rotate("Y", select);
if (key == '3')
rotate("Z", select);
if ((key == '4') && (step > 0))
{scale(select, 1.1f, 1f, 1f);}
if ((key == '4') && (step < 0))
{scale(select, 1f/1.1f, 1f, 1f);}
if ((key == '5') && (step > 0))
{scale(select, 1f, 1.1f, 1f);}
if ((key == '5') && (step < 0))
{scale(select, 1f, 1f/1.1f, 1f);}
if ((key == '6') && (step > 0))
{scale(select, 1f, 1f, 1.1f);}
if ((key == '6') && (step < 0))
{scale(select, 1f, 1f, 1f/1.1f);}
if ((key == '7') && (step > 0))
{scale(figure, 1.1f, 1f, 1f);}
if ((key == '7') && (step < 0))
{scale(figure, 1f/1.1f, 1f, 1f);}
if ((key == '8') && (step > 0))
{scale(figure, 1f, 1.1f, 1f);}
if ((key == '8') && (step < 0))
{scale(figure, 1f, 1f/1.1f, 1f);}
if ((key == '9') && (step > 0))
{scale(figure, 1f, 1f, 1.1f);}
if ((key == '9') && (step < 0))
{scale(figure, 1f, 1f, 1f/1.1f);}
if ((key == '0')&&(select instanceof Side))
{copy = (Side)select; copy.normal_Left = !(copy.normal_Left);}
if (key == 'm')
message();
if(select.field.size() != 0)
Shade.mouseUp(this);
repaint(); // else return;
}
public void keyPressed(KeyEvent e)
{
int key = e.getKeyCode();
if ((key == e.VK_UP) && !e.isControlDown() && !e.isShiftDown())
{offset = new Point(offset.x, offset.y - step);}
if ((key == e.VK_DOWN) && !e.isControlDown() && !e.isShiftDown())
{offset = new Point(offset.x, offset.y + step);}
if ((key == e.VK_LEFT) && !e.isControlDown() && !e.isShiftDown())
{offset = new Point(offset.x - step, offset.y);}
if ((key == e.VK_RIGHT) && !e.isControlDown() && !e.isShiftDown())
{offset = new Point(offset.x + step, offset.y);}
if ((key == e.VK_UP)&& e.isControlDown())
translate(select, 0, -Math.abs(step), 0);
if ((key == e.VK_DOWN)&& e.isControlDown())
translate(select, 0, Math.abs(step), 0);
if ((key == e.VK_RIGHT)&& e.isControlDown())
translate(select, Math.abs(step), 0, 0);
if ((key == e.VK_LEFT)&& e.isControlDown())
translate(select, -Math.abs(step), 0, 0);
if ((key == e.VK_END) && e.isControlDown())
translate(select, 0, 0, Math.abs(step)); //new
if ((key == e.VK_HOME) && e.isControlDown())
translate(select, 0, 0, -Math.abs(step)); //new
if ((key == e.VK_UP)&& e.isShiftDown())
translate(figure, 0, -Math.abs(step), 0);
if ((key == e.VK_DOWN)&& e.isShiftDown())
translate(figure, 0, Math.abs(step), 0);
if ((key == e.VK_RIGHT)&& e.isShiftDown())
translate(figure, Math.abs(step), 0, 0);
if ((key == e.VK_LEFT)&& e.isShiftDown())
translate(figure, -Math.abs(step), 0, 0);
if ((key == e.VK_END) && e.isShiftDown())
translate(figure, 0, 0, Math.abs(step)); //new
if ((key == e.VK_HOME) && e.isShiftDown())
translate(figure, 0, 0, -Math.abs(step)); //new
if ((key == e.VK_TAB) && !e.isControlDown() && !e.isShiftDown() && (select.field.size() != 0))
{nextSide();}
if ((key == e.VK_TAB) && e.isControlDown() && (select.field.size() != 0))
{nextElement();}
if ((key == e.VK_TAB) && e.isShiftDown() && (select.field.size() != 0))
{nextFigure();}
if (key == e.VK_PAGE_UP)
{scale(figure, 1.1f, 1.1f, 1.1f);}
if (key == e.VK_PAGE_DOWN)
{scale(figure, 1f/1.1f, 1f/1.1f, 1f/1.1f);}
if ((key == e.VK_DELETE) && !e.isControlDown() && !e.isShiftDown() && (points3D.size() != 0))
{deletelast3D(select); escape(); graph.SP.setControl();}
if ((key == e.VK_DELETE) && e.isControlDown() && (select.field.size() != 0))
{delete(select); escape(); graph.SP.setControl();}
if ((key == e.VK_DELETE) && e.isShiftDown() && (select.field.size() != 0) && (figures.size() > 1))
{delete(figure); escape(); graph.SP.setControl();}
if ((key == e.VK_ESCAPE)&&(points3D.size() != 0))
{escape();graph.SP.setControl();}
if(select.field.size() != 0)
Shade.mouseUp(this);
repaint(); // else return;
}
public void keyReleased(KeyEvent e) {}
/////////////////////////////////////////////////////////Блок удаления элементов:
public void delete(Element e)//new metod 1.1
{
while(e.field.size() != 0)
deletelast3D(e);
while(e.elements.size() != 0)
{
delete((Element)e.elements.lastElement());
e.elements.removeElement((Element)e.elements.lastElement());
}
}
public void deletelast3D(Element e)
{
if(e.field.size() != 0)
{
int t = ((Integer)e.field.lastElement()).intValue();
e.field.removeElement((Integer)e.field.lastElement());
if(!reference(t))
deletePoint3D(t);
}
}
public void deletePoint3D(int t)//new2.1
{
points3D.removeElementAt(t);
for (int i=0; i<figures.size(); i++)
trim3D(t, (Figure)figures.elementAt(i));
}
public void trim3D(int t, Element elem) //new2.2
{
elem.field.removeElement(new Integer(t));
for (int k=0, n=0; k<elem.field.size(); k++)
{
n = ((Integer)elem.field.elementAt(k)).intValue();
if(n>t)
elem.field.setElementAt(new Integer(n-1), k);
}
for (int i=0; i<elem.elements.size(); i++)
trim3D(t, (Element)elem.elements.elementAt(i));
}
public boolean reference(int t)
{
for (int i=0; i<figures.size(); i++)
{
Figure figure = (Figure)figures.elementAt(i);
for (int k=0; k<figure.elements.size(); k++)
{
Side side = (Side)figure.elements.elementAt(k);
for (int m=0, n=0; m<side.field.size(); m++)
{
n = ((Integer)side.field.elementAt(m)).intValue();
if(n==t)
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////Блок отмены методов "new ..."
public void escape()
{
if((select.field.size() == 0)&&(points3D.size() != 0))
{
if((select instanceof Side)&&((figures.size() != 1)||(figure.elements.size()!=1)))
{
figure.elements.removeElement(select);
}
else if(select instanceof Element)
{
copy.elements.removeElement(select);
}
if((figure.elements.size() == 0)&&(figures.size() > 1))
{
figures.removeElement(figure);
figure = (Figure)figures.lastElement();
}
select = (Side)figure.elements.lastElement();
}
}
///////////////////////////////////////////////////////Блок копирования элементов:
public void copy(Element e)
{
Hashtable hash = new Hashtable();
copyElement(e, hash);
}
public void copyElement(Element e, Hashtable hash)
{
if(e instanceof Figure)
{
figures.addElement(figure = new Figure(this, e.kind, e.color, e.full, figure.net, figure.flag_backface));
for (int i=0; i<e.elements.size(); i++)
copyElement((Side)e.elements.elementAt(i), hash);
}
else if(e instanceof Side)
{
figure.elements.addElement(select = new Side(this, e.kind, e.color, e.full));
copyPoint3D(e.field, hash);
copy = (Side)select;
for (int i=0; i<e.elements.size(); i++)
copyElement((Element)e.elements.elementAt(i), hash);
}
else if(e instanceof Element)
{
copy.elements.addElement(select = new Element(this, e.kind, e.color, e.full));
copyPoint3D(e.field, hash);
}
}
public void copyPoint3D(Vector vector, Hashtable hash)
{
for (int i=0, t=0, n=0; i<vector.size(); i++)
{
t = ((Integer)vector.elementAt(i)).intValue();
if((select instanceof Side)&&(hash.containsKey(new Integer(t)))) //если существующая точка стороны нового эл-та ,то:
select.add(((Integer)hash.get(new Integer(t))).intValue());
else
{
n = points3D.size();
select.add(n);
figure.add(n);
hash.put(new Integer(t), new Integer(n));
points3D.addElement(Point3D.copy((Point3D)points3D.elementAt(t)));
}
}
}
///////////////////////////////////////////////////////Блок создания элементов:
public void newElement()
{
if(select instanceof Side)
copy = (Side)select;
copy.elements.addElement(select = new Element(this, kind, color, full));
message();
}
public void newSide()
{
figure.elements.addElement(select = new Side(this, kind, color, full));
message();
}
public void newFigure()
{
figures.addElement(figure = new Figure(this, kind, Color.black, full, net, flag_backface));
figure.elements.addElement(select = new Side(this, kind, color, full));
message();
}
//////////////////////////////////////////////////Блок навигации по элементам:
public void next_offset()
{
next(select.field);
int t = ((Integer)select.field.elementAt(tab)).intValue();
Point3D p = (Point3D)points3D.elementAt(t);
offset.translate(Math.round(p.x), Math.round(p.y));//new
matrix.identity();
matrix.translate(-p.x, -p.y, -p.z);
for (int i=0; i<points3D.size(); i++)
matrix.transform((Point3D)points3D.elementAt(i));
}
public void nextSide()
{
next(figure.elements);
select = (Side)figure.elements.elementAt(tab);
graph.SP.setControl();
}
public void nextElement()
{
if(select instanceof Side)
copy = (Side)select;
if(copy.elements.size() == 0)
return;
next(copy.elements);
select = (Element)copy.elements.elementAt(tab);
graph.SP.setControl();
}
public void nextFigure()
{
next(figures);
figure = (Figure)figures.elementAt(tab);
select = (Side)figure.elements.elementAt(0);
graph.SP.setControl();
}
public void next(Vector vector)
{
tab = Math.min(Math.max(0, tab + tab_add), vector.size()-1);
if(tab == vector.size()-1)
tab_add = -1;
else if(tab == 0)
tab_add = 1;
}
//////////////////////////////////////////////////////Блок реконструкции элементов:
public void reconstruct_A(Element elem)
{
float xc, yc, zc;
int k = select.field.size();
matrix.identity();
matrix.rotate(turn, "Z", false);
for (int i=0,t=0; i<k; i++)
{
t = ((Integer)select.field.elementAt(i)).intValue();
select.add(points3D.size());
figure.add(points3D.size());
points3D.addElement(matrix.transform(Point3D.copy((Point3D)points3D.elementAt(t))));
}
turnSum += turn;
turn *= 2.0f;
}
///////////////////////////////////////////////////////Блок вращения элементов:
public void rotate(String axis, Element e)
{
matrix.identity();
matrix.rotate(rotate, axis, false);
transform(matrix, e.field);
if((e instanceof Side)&&(!(e instanceof Figure))) //else if???
for (int k=0; k<e.elements.size(); k++)
{
Element elem =(Element)e.elements.elementAt(k);
rotate(axis, elem);
}
}
///////////////////////////////////////////////////////Блок перемещения элементов:
public void translate(Element e, int dx, int dy, int dz)
{
matrix.identity();
matrix.translate(dx, dy, dz);
transform(matrix, e.field);
if((e instanceof Side)&&(!(e instanceof Figure))) //else if???
for (int k=0; k<e.elements.size(); k++)
{
Element elem =(Element)e.elements.elementAt(k);
translate(elem, dx, dy, dz);
}
}
///////////////////////////////////////////////////////Блок масштабирования элементов:
public void scale( Element e, float x, float y, float z)
{
matrix.identity();
matrix.scale(x, y, z);
transform(matrix, e.field);
if((e instanceof Side)&&(!(e instanceof Figure))) //else if ???
for (int k=0; k<e.elements.size(); k++)
{
Element elem =(Element)e.elements.elementAt(k);
scale(elem, x, y, z);
}
}
///////////////////////////////////////////////////////Блок "face" сторон фигуры.
public void face(Side side, boolean alone)//положить сторону на поверхность рисования.
{
Vector3D nV = side.normal();
matrix.identity();
matrix.rotate(Math.atan2(nV.z, nV.x),"Y", true);
matrix.rotate(-Math.atan2(nV.y, Math.sqrt(nV.x*nV.x + nV.z*nV.z)),"Z", true);
matrix.rotate(Math.PI/2, "Y", true);
if(alone)
{
transform(matrix, side.field);
for (int k=0; k<side.elements.size(); k++)
transform(matrix, ((Element)side.elements.elementAt(k)).field);
}
else
transform(matrix, figure.field);
}
///////////////////////////////////////////////////////общий Блок:
public void transform(Matrix3D m, Vector v) //метод, вызываемый после изменения СК
{
for (int i=0, t=0; i<v.size(); i++)
{
t = ((Integer)v.elementAt(i)).intValue();
m.transform((Point3D)points3D.elementAt(t));
}
}
///////////////////////////////////////////////////////Блок для рисования элементов:
public void update(Graphics g)
{
if(offScreen == null) //start new text:
{
offScreenImage = createImage(getSize().width, getSize().height);
offScreen = offScreenImage.getGraphics();
} //end new metod;
offScreen.setColor(getBackground());
offScreen.fillRect(0, 0, getSize().width, getSize().height);
paint(offScreen);
g.drawImage(offScreenImage, 0, 0, this);
FP.repaint();
requestFocus();
}
public void paint(Graphics g)
{
for (int i=0; i<figures.size(); i++)
{
Figure figure = (Figure)figures.elementAt(i);
sort(figure.elements);
figure.draw(g, offset, "view Face");
if(figure.net)
{
g.setColor(Color.black);
Side side;
for(int k=0; k<figure.elements.size(); k++)
net(g, ((Side)figure.elements.elementAt(k)).field);
}
}
if (offset != null)
{ g.setColor(Color.black); g.fillOval(offset.x - 3, offset.y - 3, 6, 6);}
if (select instanceof Side)
{ g.setColor(Color.red); net(g, select.field);}
else if(select instanceof Element)
{ g.setColor(Color.green); net(g, copy.field);}
if (select.field.size() != 0)
{
int t = ((Integer)select.field.lastElement()).intValue();
Point3D p = (Point3D)points3D.elementAt(t);
g.drawOval(offset.x + Math.round(p.x) - 3, offset.y + Math.round(p.y) - 3, 6, 6);
}
}
public void net(Graphics g, Vector vector)
{
for (int i=0, t=0; i<vector.size(); i++)
{
t = ((Integer)vector.elementAt(i)).intValue();
Point3D p = (Point3D)points3D.elementAt(t);
g.drawOval(offset.x + Math.round(p.x) - 5, offset.y + Math.round(p.y) - 5, 10, 10);
}
}
public void sort(Vector v)
{
int j = v.size();
while(--j > 0)
{
for (int i=0; i<j; i++)
{
if (((Side)v.elementAt(i)).weight() < ((Side)v.elementAt(i+1)).weight())
{
Side temp = (Side)v.elementAt(i);
v.setElementAt((Side)v.elementAt(i+1), i);
v.setElementAt(temp, i+1);
}
}
}
}
} | [
"[email protected]"
] | |
f218dee58e8713a056b91d339998db50ddbd9d23 | 9cd45a02087dac52ea4d39a0c17e525c11a8ed97 | /src/java/com/appnext/core/AppnextActivity.java | 957ff1e850aec67d976418d528df00852366c585 | [] | no_license | abhijeetvaidya24/INFO-NDVaidya | fffb90b8cb4478399753e3c13c4813e7e67aea19 | 64d69250163e2d8d165e8541aec75b818c2d21c5 | refs/heads/master | 2022-11-29T16:03:21.503079 | 2020-08-12T06:00:59 | 2020-08-12T06:00:59 | 286,928,296 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,499 | java | /*
* Decompiled with CFR 0.0.
*
* Could not load the following classes:
* android.annotation.SuppressLint
* android.app.Activity
* android.content.Context
* android.graphics.Color
* android.graphics.drawable.Drawable
* android.os.Build
* android.os.Build$VERSION
* android.os.Bundle
* android.os.Handler
* android.util.AttributeSet
* android.view.View
* android.view.View$OnClickListener
* android.view.ViewGroup
* android.view.ViewGroup$LayoutParams
* android.view.ViewParent
* android.view.Window
* android.view.animation.Animation
* android.view.animation.RotateAnimation
* android.widget.ProgressBar
* android.widget.RelativeLayout
* android.widget.RelativeLayout$LayoutParams
* com.appnext.core.AppnextAd
* com.appnext.core.e
* com.appnext.core.e$a
* com.appnext.core.f
* com.appnext.core.p
* com.appnext.core.q
* java.lang.Object
* java.lang.Runnable
* java.lang.String
* java.lang.Thread
* java.lang.Throwable
*/
package com.appnext.core;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.Window;
import android.view.animation.Animation;
import android.view.animation.RotateAnimation;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import com.appnext.core.AppnextAd;
import com.appnext.core.e;
import com.appnext.core.f;
import com.appnext.core.p;
import com.appnext.core.q;
public abstract class AppnextActivity
extends Activity {
protected String banner = "";
protected String gm = "";
private RelativeLayout gn;
protected RelativeLayout go;
protected String guid = "";
protected Handler handler;
protected String placementID;
protected q userAction;
protected final void a(ViewGroup viewGroup, Drawable drawable2) {
if (this.gn != null) {
this.aY();
}
this.gn = new RelativeLayout((Context)this);
this.gn.setBackgroundColor(Color.parseColor((String)"#77ffffff"));
viewGroup.addView((View)this.gn);
this.gn.getLayoutParams().height = -1;
this.gn.getLayoutParams().width = -1;
ProgressBar progressBar = new ProgressBar((Context)this, null, 16842871);
progressBar.setIndeterminateDrawable(drawable2);
progressBar.setIndeterminate(true);
this.gn.addView((View)progressBar);
RotateAnimation rotateAnimation = new RotateAnimation(360.0f, 0.0f, 1, 0.5f, 1, 0.5f);
rotateAnimation.setDuration(1000L);
rotateAnimation.setRepeatCount(-1);
progressBar.setAnimation((Animation)rotateAnimation);
((RelativeLayout.LayoutParams)progressBar.getLayoutParams()).addRule(13, -1);
this.gn.setOnClickListener(new View.OnClickListener(){
public final void onClick(View view) {
}
});
this.handler.postDelayed(new Runnable(){
public final void run() {
AppnextActivity.this.aY();
}
}, 8000L);
}
protected void a(AppnextAd appnextAd, e.a a2) {
q q2 = this.userAction;
if (q2 != null && appnextAd != null) {
q2.a(appnextAd, appnextAd.getImpressionURL(), a2);
}
}
@SuppressLint(value={"NewApi"})
protected final void aW() {
int n2 = 2 ^ this.getWindow().getDecorView().getSystemUiVisibility();
if (Build.VERSION.SDK_INT >= 16) {
n2 ^= 4;
}
if (Build.VERSION.SDK_INT >= 18) {
n2 ^= 4096;
}
this.getWindow().getDecorView().setSystemUiVisibility(n2);
}
@SuppressLint(value={"NewApi"})
protected final void aX() {
int n2 = 2 | this.getWindow().getDecorView().getSystemUiVisibility();
if (Build.VERSION.SDK_INT >= 16) {
n2 |= 4;
}
if (Build.VERSION.SDK_INT >= 18) {
n2 |= 4096;
}
this.getWindow().getDecorView().setSystemUiVisibility(n2);
}
protected final void aY() {
Handler handler;
RelativeLayout relativeLayout = this.gn;
if (relativeLayout != null) {
relativeLayout.removeAllViews();
this.gn.removeAllViewsInLayout();
if (this.gn.getParent() != null) {
((RelativeLayout)this.gn.getParent()).removeView((View)this.gn);
}
}
if ((handler = this.handler) != null) {
handler.removeCallbacks(null);
}
this.gn = null;
}
protected void b(AppnextAd appnextAd, e.a a2) {
q q2 = this.userAction;
if (q2 != null && appnextAd != null) {
q2.a(appnextAd, appnextAd.getAppURL(), this.placementID, a2);
}
}
protected abstract p getConfig();
protected void onCreate(Bundle bundle) {
new Thread(new Runnable(){
public final void run() {
if (!f.s((Context)AppnextActivity.this)) {
AppnextActivity.this.finish();
AppnextActivity.this.runOnUiThread(new Runnable(){
public final void run() {
AppnextActivity.this.onError("Connection Error");
}
});
}
}
}).start();
this.requestWindowFeature(1);
this.getWindow().setFlags(1024, 1024);
this.getWindow().addFlags(128);
super.onCreate(bundle);
this.handler = new Handler();
}
/*
* Unable to fully structure code
* Enabled aggressive block sorting
* Enabled unnecessary exception pruning
* Enabled aggressive exception aggregation
* Lifted jumps to return sites
*/
protected void onDestroy() {
super.onDestroy();
try {
this.handler.removeCallbacks(null);
this.handler = null;
** GOTO lbl-1000
}
catch (Throwable v0) {
try lbl-1000: // 2 sources:
{
this.userAction.destroy();
this.userAction = null;
return;
}
catch (Throwable v1) {}
}
}
protected abstract void onError(String var1);
}
| [
"[email protected]"
] | |
dca37a5a93e256a212f3255638c43b68513505b2 | 5fa4f4c05d2946d5419882e8e709279111903193 | /src/main/java/music/mapper/UserMapper.java | 8b1b3d2d0e4ae211362e08d31edee2d2269f795c | [] | no_license | maybe-fb/music | 71752677e8799146de53f645f3983ac1638650df | c2d391e8f63def7668f85fabbb7dd197f6913435 | refs/heads/master | 2023-05-26T19:52:07.786999 | 2017-02-19T07:20:47 | 2017-02-19T07:20:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 948 | java | package music.mapper;
import java.util.List;
import music.beans.UserBean;
public interface UserMapper {
/**
* 新增用戶
* @param user
* @return
* @throws Exception
*/
public int insertUser(UserBean user) throws Exception;
/**
* 修改用戶
* @param user
* @param id
* @return
* @throws Exception
*/
public int updateUser (UserBean user,int id) throws Exception;
/**
* 刪除用戶
* @param username
* @return
* @throws Exception
*/
public int deleteUser(String username) throws Exception;
/**
* 根据id查询用户信息
* @param id
* @return
* @throws Exception
*/
public UserBean selectUserByUsername(String username) throws Exception;
/**
* 查询所有的用户信息
* @return
* @throws Exception
*/
public List<UserBean> selectAllUser() throws Exception;
} | [
"canjie@canjie-z"
] | canjie@canjie-z |
3c508d29feeb40cdadbcdaa373881e9fde377d7b | 77d776f1d716e13dd9e40f2c885a26ad89b8f178 | /0429update/src/com/boco/SYS/mapper/FdOrganMapper.java | 2a8fc1c7f17a6bbdc7101b817a8a2db63a1a17d0 | [] | no_license | AlessaVoid/studyCode | 076dc132b7e24cb341d5a262f8f96d7fa78c848b | 0b8806a537a081535992a467ad4ae7d5dcf7ab3e | refs/heads/master | 2022-12-18T20:40:47.169951 | 2020-09-18T08:28:02 | 2020-09-18T08:28:02 | null | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 2,965 | java | package com.boco.SYS.mapper;
import com.boco.SYS.base.GenericMapper;
import com.boco.SYS.entity.FdOrgan;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* FdOrgan数据访问层(父类已实现增、删、改、查操作，只有特殊业务时需要自定义方法)
*
* <pre>
* 修改日期 修改人 修改原因
* 2014-10-29 杨滔 批量新建
* </pre>
*/
public interface FdOrganMapper extends GenericMapper<FdOrgan, java.lang.String> {
/**
* TODO 获取一分机构.
*
* @return <pre>
* 修改日期 修改人 修改原因
* 2016年3月4日 杜旭 新建
* </pre>
*/
public List<FdOrgan> selectProvOrgan();
String selectOrganName(String thiscode);
/**
* TODO 查询某机构的直属下级机构
*
* @param thiscode
* @return <pre>
* 修改日期 修改人 修改原因
* 2016年4月5日 李沐阳 新建
* </pre>
*/
public List<Map<String, String>> findNextOrganCodeList(String thiscode);
/**
* TODO 获取机构名称.
*
* @param organs
* @return <pre>
* 修改日期 修改人 修改原因
* 2016年3月30日 杜旭 新建
* </pre>
*/
public List<Map<String, String>> selectProvName(String[] organs);
/**
* TODO 获取产品发售机构
*
* @param areaCodes
* @return <pre>
* 修改日期 修改人 修改原因
* 2016年10月9日 谷立羊 新建
* </pre>
*/
public List<FdOrgan> selectByAreaCodes(String[] organs);
/**
* 联想,机构名称
*
* @param fdOrgan 名称
* @return
*/
public List<String> selectByName(FdOrgan fdOrgan);
/**
* 联想,机构编码
*
* @param fdOrgan 名称
* @return
*/
public List<String> selectByThisCode(FdOrgan fdOrgan);
/**
* 根据机构号，查询下级所有机构
* @param uporgan
* @return
*/
List<Map<String, Object>> selectByUporgan(String uporgan);
List<FdOrgan> selectList(Map<String, Object> map);
//查询当前机构
List<Map<String, Object>> selectByOrganCode(String thiscode);
List<String> selectByLikeThisCode(FdOrgan fdOrgan);
List<String> selectByLikeThisCodeZX(FdOrgan fdOrgan);
List<String> selectByLikeName(FdOrgan fdOrgan);
List<String> selectByLikeNameZX(String thiscode);
String selectUporganByThisCodeList(String thiscode);//根据thiscodelist查询uporgan
String selectOrganNameBycode(String thiscode);
List<String> selectthiscodeByLikeOrganname(String uporgan);//通过organname模糊查询对应的thiscode
List<Map<String, Object>> selectByLikeOrganname(@Param("organname") String organname);
//去除了总行，总行机构，邮储
List<FdOrgan> selectByAttr2(FdOrgan fdOrgan);
} | [
"[email protected]"
] | |
b796f050bdf53f5c678102534894bd92c027839d | c05eaef035b86e90a04216aca86cb507388e0921 | /ZCart/ZCartDriver.java | e1006934bac83623f3514d1957533c62175a43b3 | [] | no_license | meelement/Zoho | 4128cfcce5b720777fb2d674b952c6be4ac93438 | 783b84d462490cf3a18fddaa78e9487ae4b84332 | refs/heads/main | 2023-08-28T01:57:01.722986 | 2021-10-27T05:08:35 | 2021-10-27T05:08:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 13,652 | java | package ZCart;
import java.io.*;
import java.util.*;
import java.util.regex.Pattern;
public class ZCartDriver {
private int productId=1;
private int invoiceNumber=1;
private List<Integer> highStockProductId=new ArrayList<>();
private int highStocks=0;
private static final String adminUser="[email protected]";
private static String adminPassword="xyzzy";
ZCartManagement cache=new ZCartManagement();
public void initialSetUp(){
try {
setCustomerDetails();
setProductDetails();
} catch (IOException e) {
e.printStackTrace();
}
}
public void setAdminPassword(String password){
adminPassword=password;
}
private void setProductDetails() throws IOException {
FileReader file=new FileReader("products.txt");
BufferedReader bufferedReader1=new BufferedReader(file);
String str1;
while ((str1=bufferedReader1.readLine())!=null){
String[]array=str1.split(":");
int itemId=Integer.parseInt(array[0]);
String category=array[1];
String brand=array[2];
String model=array[3];
double price=Double.parseDouble(array[4]);
int stock=Integer.parseInt(array[5]);
Product item = getProduct(itemId, category, brand, model, price, stock);
cache.setProductDetails(item);
}
setHighStockProductId();
file.close();
bufferedReader1.close();
}
private void setCustomerDetails() throws IOException {
FileReader fileReader=new FileReader("customer.txt");
BufferedReader bufferedReader=new BufferedReader(fileReader);
String str;
while ((str=bufferedReader.readLine())!=null){
String[]array=str.split(":");
String name=array[0];
String userName=array[1];
String password=array[2];
long mobile=Long.parseLong(array[3]);
Customer customer = getCustomer(name, userName, password, mobile);
customer=getPurchaseDetails(customer);
cache.setCustomerDetails(customer);
}
fileReader.close();
bufferedReader.close();
}
private void setHighStockProductId(){
Collection<Map<Integer, Product>> allProducts=cache.getProductDetails().values();
for (Map<Integer,Product>map:allProducts){
Collection<Product>products=map.values();
for (Product product:products){
if(product.getStock()>highStocks){
highStocks=product.getStock();
highStockProductId.clear();
}
if(product.getStock()==highStocks){
highStockProductId.add(product.getItemId());
}
}
}
}
private Customer getPurchaseDetails(Customer customer){
String username=customer.getUserName();
try {
FileReader fileReader=new FileReader(username+".txt");
BufferedReader bufferedReader=new BufferedReader(fileReader);
String str;
List<Integer> invoices=new ArrayList<>();
Map<String,Integer>couponCodes=new HashMap<>();
while ((str=bufferedReader.readLine())!=null){
String[]array=str.split(":");
if(array[0].equals("Invoice")){
invoices.add(Integer.parseInt(array[1]));
}else {
String[]codes=array[1].split("=");
String code=codes[0];
int usage=Integer.parseInt(codes[1]);
couponCodes.put(code,usage);
}
}
customer.setInvoices(invoices);
customer.setCoupon(couponCodes);
} catch (IOException e) {
e.printStackTrace();
}
return customer;
}
public boolean signUp(Customer customer){
Map<String,Customer>customerDetails= cache.getCustomerDetails();
String userName=customer.getUserName();
if(customerDetails.containsKey(userName)){
return false;
}
String password=customer.getPassword();
String encrypted=encryptPassword(password);
customer.setPassword(encrypted);
cache.setCustomerDetails(customer);
updateFile(customer);
createFile(userName);
return true;
}
private void createFile(String userName){
File file=new File(userName+".txt");
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
private void updateFile(Customer customer){
String name=customer.getName();
String userName=customer.getUserName();
String password=customer.getPassword();
long mobile=customer.getMobileNumber();
String str=name+":"+userName+":"+password+":"+mobile;
try {
FileWriter fileWriter=new FileWriter("customer.txt",true);
BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
bufferedWriter.write(str);
bufferedWriter.close();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void updateFile(Product product){
int productId=product.getItemId();
String category=product.getCategory();
String brand=product.getBrand();
String model=product.getModel();
int stock=product.getStock();
double price= product.getPrice();
String str=productId+":"+category+":"+brand+":"+model+":"+price+":"+stock;
try {
FileWriter fileWriter=new FileWriter("products.txt",true);
BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
bufferedWriter.write(str);
bufferedWriter.close();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void deleteProductFile(){
File file=new File("products.txt");
file.delete();
}
public void updateProductFile(){
Collection<Map<Integer, Product>> allProducts=cache.getProductDetails().values();
for (Map<Integer,Product>map:allProducts){
Collection<Product>products=map.values();
for (Product product:products){
updateFile(product);
}
}
}
public void updateFile(Invoice invoice,String userName){
int invoiceNumber=invoice.getInvoiceNumber();
String str="Invoice:"+invoiceNumber;
try {
FileWriter fileWriter=new FileWriter(userName+".txt",true);
BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
bufferedWriter.write(str);
bufferedWriter.close();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void addProduct(Product product){
product.setItemId(productId);
updateFile(product);
cache.setProductDetails(product);
productId++;
}
public Collection<Product> getProduct(String category){
Map<Integer,Product> products=cache.getProductDetails().get(category);
if(products==null){
return null;
}
return products.values();
}
public Product shopProduct(int productId, String category){
Map<Integer,Product> products=cache.getProductDetails().get(category);
Product product=products.get(productId);
if(product==null){
return null;
}
int stock=product.getStock();
if(stock==0){
return null;
}
return product;
}
public Invoice checkOut(List<Product>products, String userName, String couponCode){
Customer customer=cache.getCustomerDetails().get(userName);
Invoice invoice=new Invoice();
invoice.setInvoiceNumber(invoiceNumber);
for(Product product:products){
int productId=product.getItemId();
double amount=product.getPrice();
int stock=product.getStock();
if(stock==0){
continue;
}
product.setStock(-1);
invoice.setItems(productId,1);
invoice.setTotalAmount(amount);
double discount=checkCouponCode(couponCode,userName);
if(highStockProductId.contains(productId)){
discount+=product.getPrice()*0.1;
}
invoice.setSavingAmount(discount);
}
int numOfPurchases=customer.getInvoices().size();
if(numOfPurchases==3||invoice.getTotalAmount()>=20000){
String code=createCouponCode(customer);
customer.setCoupon(code);
}
deleteProductFile();
updateProductFile();
setHighStockProductId();
customer.setInvoices(invoiceNumber);
cache.setInvoiceDetails(invoice);
updateFile(invoice,userName);
invoiceNumber++;
return invoice;
}
public List<Product> getLessStocks(){
List<Product>lessStocks=new ArrayList<>();
Collection<Map<Integer, Product>> allProducts=cache.getProductDetails().values();
for (Map<Integer,Product>map:allProducts){
Collection<Product>products=map.values();
for (Product product:products){
if(product.getStock()<10){
lessStocks.add(product);
}
}
}
return lessStocks;
}
public List<Invoice> getInvoices(String userName){
Customer customer=cache.getCustomerDetails().get(userName);
List<Integer>invoiceNumbers=customer.getInvoices();
List<Invoice>invoices=new ArrayList<>();
for (int invoiceNumber:invoiceNumbers){
Invoice invoice=cache.getInvoiceDetails().get(invoiceNumber);
invoices.add(invoice);
}
return invoices;
}
public void reOrder(List<Product>products){
for (Product product:products){
product.setStock(10);
}
deleteProductFile();
updateProductFile();
}
public String createCouponCode(Customer customer){
String alphaNumeric="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
StringBuilder code=new StringBuilder();
for (int i=0;i<6;i++){
int index= (int) (alphaNumeric.length()*Math.random());
code.append(alphaNumeric.charAt(index));
}
return code.toString();
}
public int checkCouponCode(String couponCode,String userName){
Customer customer=cache.getCustomerDetails().get(userName);
Map<String,Integer>coupon=customer.getCoupon();
if(coupon!=null&&!coupon.isEmpty()){
int number=coupon.get(couponCode);
if(number==0){
return 0;
}
coupon.put(couponCode,number-1);
int discount= (int) (Math.random() * (30 - 20 + 1)+20);
return discount;
}
return 0;
}
public boolean checkPassword(String password){
if (Pattern.matches("(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).{8,20}",password)){
return true;
}
return false;
}
private String encryptPassword(String password){
char[]chars=password.toCharArray();
StringBuilder encryptedPassword=new StringBuilder();
char k;
for(char c:chars){
if(c=='Z'){
k='A';
}else if(c=='z'){
k='a';
}
else if(c=='9'){
k='0';
}else {
k= (char) (c+1);
}
encryptedPassword.append(k);
}
return encryptedPassword.toString();
}
private String decryptPassword(String password){
char[]chars=password.toCharArray();
StringBuilder decrypted =new StringBuilder();
char k;
for(char c:chars){
if(c=='A'){
k='Z';
}else if(c=='a'){
k='z';
}
else if(c=='0'){
k='9';
}else {
k= (char) (c-1);
}
decrypted.append(k);
}
return decrypted.toString();
}
public boolean userLogin(String userName,String password){
Customer customer= cache.getCustomerDetails().get(userName);
if(customer==null){
return false;
}
String encrypted=customer.getPassword();
String decrypted=decryptPassword(encrypted);
if(decrypted.equals(password)){
return true;
}
return false;
}
public boolean adminLogin(String userName,String password){
return userName.equals(adminUser)&&password.equals(adminPassword);
}
public Product getProduct(int itemId, String category, String brand, String model, double price, int stock) {
Product item=new Product();
item.setItemId(itemId);
item.setCategory(category);
item.setBrand(brand);
item.setModel(model);
item.setStock(stock);
item.setPrice(price);
return item;
}
public Customer getCustomer(String name, String userName, String password, long mobile) {
Customer customer=new Customer();
customer.setName(name);
customer.setPassword(password);
customer.setUserName(userName);
customer.setMobileNumber(mobile);
return customer;
}
}
| [
"[email protected]"
] | |
efe06fb9c38ddc49925eea08371dc9c54d13c45c | 139e25442479c3262dd87aec01473c1c0d63279f | /google2/src/test/java/google2/consultar.java | 654391b2755ff311218f4eae8f34177029ad3bc0 | [] | no_license | rafanicola/fts124-nicola | e95aa097b8249e0a45706cdacc1aad295fab3e96 | d3bc063726866c468e287a24a441d6a0150d6156 | refs/heads/master | 2021-06-23T06:39:01.479045 | 2020-01-24T17:28:58 | 2020-01-24T17:28:58 | 219,621,840 | 1 | 0 | null | 2021-04-26T19:39:42 | 2019-11-05T00:19:19 | JavaScript | ISO-8859-1 | Java | false | false | 2,588 | java | package google2;
import static org.junit.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import cucumber.api.java.After;
import cucumber.api.java.Before;
import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;
public class consultar {
String url;
WebDriver driver;
static String pastaPrint = new SimpleDateFormat("yyyy-MM-dd HH-mm").format(Calendar.getInstance().getTime());
// Funções de Apoio
public void Print(String nomePrint) throws IOException {
File foto = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(foto,
new File("C:\\Users\\rafaelnicola\\fts-124workspace\\google2\\target\\prints\\" + pastaPrint + "\\" + nomePrint + ".png"));
}
@Before
public void Iniciar() {
url = "https://www.google.com.br";
System.setProperty("webdriver.chrome.driver",
"C:\\Users\\rafaelnicola\\fts-124workspace\\google2\\drivers\\chrome\\78\\chromedriver_win32\\chromedriver.exe");
driver = new ChromeDriver();
driver.manage().timeouts().implicitlyWait(30000, TimeUnit.MILLISECONDS);
}
@After
public void Finalizar() {
driver.quit();
}
@Given("que acesso o site do Google$")
public void que_acesso_o_site_do_Google() throws Throwable {
System.out.println("Passo 1 - Abre o Google");
driver.get(url);
Print("Consultar\\Passo 1 - Abre o Google");
}
@When("digito o termo \"([^\"]*)\" e pressiono Enter$")
public void digito_o_termo_e_pressiono_Enter(String termo) throws Throwable {
System.out.println("Passo 2 - Digita o termo e pressiona Enter");
driver.findElement(By.name("q")).clear();
driver.findElement(By.name("q")).sendKeys(termo);
Print("Consultar\\Passo 2 - Digita o termo");
driver.findElement(By.name("q")).sendKeys(Keys.ENTER);
}
@Then("Vejo os resultados e a guia \"([^\"]*)\"$")
public void vejo_os_resultados_e_a_guia(String tituloEsperado) throws Throwable {
System.out.println("Passo 3 - Exibe os resultados e o nome da guia");
assertEquals(tituloEsperado, driver.getTitle());
Print("Consultar\\Passo 3 - Exibe os resultados e o nome da guia");
}
}
| [
"[email protected]"
] | |
a7f814edfee01f00d6da6fa5b4ad29537673a48f | b7eab45960d8bf86a0557c665623b17297f81951 | /src/me.pluginTest/Main.java | 720b9490f1205f270b50f051bcf9328ab789175c | [] | no_license | wannapaly/MC-Plugin-test | fabca6342003bf642a6abb2b4457938bf8534b3e | a61be39e426d0b975f831cdddfe61c613f0e6697 | refs/heads/master | 2023-02-05T07:21:48.833907 | 2020-12-26T01:22:56 | 2020-12-26T01:22:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 110 | java | package me.pluginTest;
import org.bukkit.plugin.java.JavaPlugin;
public class main extends JavaPlugin{
}
| [
"[email protected]"
] | |
4265bf19e0647384a1fa454ab0e18059815d8aee | 594ff1fe200a9658d5e511d10e8d5d81b47c7e07 | /rdv-data/src/test/java/com/yannic/rdv/data/repository/BasicTest.java | ef60fb9e2984f237bdb228d1c35891ba96b5e217 | [
"MIT"
] | permissive | yannicl/rdv | 14de7be636b0e9dfb1e65c46283298c42d23c14e | 722467cdb1c67252b94f9ae996c1fcb163ff51d0 | refs/heads/master | 2021-01-15T23:34:57.145207 | 2015-05-23T02:05:23 | 2015-05-23T02:05:23 | 26,404,287 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,548 | java | package com.yannic.rdv.data.repository;
import org.junit.Assert;
import org.junit.Test;
import com.github.springtestdbunit.annotation.DatabaseSetup;
import com.yannic.rdv.data.model.Account;
import com.yannic.rdv.data.model.Event;
import com.yannic.rdv.data.model.Person;
@DatabaseSetup("basic_dataset_1.xml")
public class BasicTest extends BaseTest {
@Test
public void should_have_1_organizer() {
Assert.assertEquals(1, organizerRepository.count());
}
@Test
public void should_have_1_person() {
Assert.assertEquals(1, organizerRepository.count());
}
@Test
public void should_have_1_location() {
Assert.assertEquals(1, locationRepository.count());
}
@Test
public void should_have_1_event() {
Assert.assertEquals(1, eventRepository.count());
}
@Test
public void should_have_1_account() {
Assert.assertEquals(1, accountRepository.count());
}
@Test
public void event_should_be_linked_to_other_objects() {
Event event = eventRepository.findOne((long) 1);
Assert.assertNotNull(event.getAttendee());
Assert.assertNotNull(event.getLocation());
Assert.assertNotNull(event.getOrganizer());
}
@Test
public void account_should_be_linked_to_person() {
Account account = accountRepository.findOne((long) 1);
Person person = personRepository.findOne((long) 1);
Assert.assertNotNull(account.getAccountPersonAssociations());
Assert.assertEquals(1, account.getAccountPersonAssociations().size());
Assert.assertEquals(person, account.getAccountPersonAssociations().get(0).getPerson());
}
}
| [
"[email protected]"
] | |
7124947c58caed2e917acf8bf89107736c883a08 | 895b2680c38941aef87ad9a97d0de6588ceba314 | /esnManagement/src/main/java/com/emt/exception/UserAldreadyExistsException.java | fac49976f9a508634c87c6c2e05b5d53e0f9bc30 | [] | no_license | rohipedia/ESN-Merged-Code | 303c018f09ed40ef35a1a0a119992aa07321b2a9 | c279ebbc657d8efc4e42e535dd273d6a0c720a90 | refs/heads/master | 2020-03-22T03:19:47.195339 | 2018-08-06T15:45:48 | 2018-08-06T15:45:48 | 139,425,584 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,386 | java | package com.emt.exception;
import java.util.HashMap;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;
@Slf4j
public class UserAldreadyExistsException extends RuntimeException {
private static final long serialVersionUID = 42L;
/**
* Any miscellaneous error data to be passed on to the Handlers.
*/
private Map<String, Object> extraErrorData;
public UserAldreadyExistsException(String message, Throwable cause) {
super(message, cause);
}
public UserAldreadyExistsException(String message) {
super(message);
}
public UserAldreadyExistsException(Throwable cause) {
super(cause);
}
/**
* Add Error Data
*
* @param key
* @param data
*/
public void addErrorData(String key, Object data) {
if (extraErrorData == null) {
// Create a Map with initial capacity of 5, instead of the default
// of 16
extraErrorData = new HashMap<String, Object>(5);
}
log.info("Adding error data for the error having key" +key);
extraErrorData.put(key, data);
}
/**
* Get a Particular Error Data.
*
* @param key
*/
public Object getErrorData(String key) {
if (this.extraErrorData == null) {
log.info("No error data found for the error having key"+key);
return null;
}
log.info("Fetching error data for the error having key" +key);
return this.extraErrorData.get(key);
}
}
| [
"[email protected]"
] | |
b49e206e96f1913b774e18a193d6d7c6d93aa17e | 4bb19c88d6f9ffa5a457d0907dfe9679710412d9 | /myjava_code/day02/TestJinZhi.java | fe7d95809d71ad54bbd8ce36e74a908d50045900 | [] | no_license | wydhcws/JAVA | f1c9ad4bd48a98b1727d220d8e7bfb1683cabb3c | 9e0110cceff61b4843826e5e19f82a305f300e6a | refs/heads/master | 2021-10-28T10:10:23.049695 | 2019-04-23T11:45:10 | 2019-04-23T11:45:10 | 80,534,395 | 0 | 1 | null | null | null | null | GB18030 | Java | false | false | 2,137 | java | /*
进制：
二进制（计算机世界中） 逢二进一 0-1
十进制（生活中，人习惯的） 逢十进一 0-9
八进制 逢八进一 0-7
十六进制 逢十六进一 0-9 a-f
十进制 二进制 八进制 十六进制
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 a （大小写都可以）
11 1011 13 b
12 1100 14 c
13 1101 15 d
14 1110 16 e
15 1111 17 f
16 10000 20 10
在程序中如何表示各种进制的数字：
二进制：数字前面加0b或0B
十进制：正常表示
八进制：数字前面加0
十六进制：数字前面加0x
十进制的25的二进制值是多少？
整数部分：除2倒取余
小数部分：乘2取整数部分
二进制到十进制如何换算？
从最右边开始依次是2的0次，1次，2次...
八进制和十六进制与二进制的关系
二进制的三位，相当于八进制的一位
二进制的四位，相当于十六进制的一位
1个字节，为什么是-128~127?
1个字节是八位
最高位是符号位，0表示正数，1表示负数
byte：
25 -> 0001 1001
-25 ->1001 1001
原码，反码，补码
正数，三码合一，原码，反码，补码都一样
负数，反码是除了符号位原码取反
补码是反码+1
-25 ->原码 1001 1001
反码 1110 0110
补码 1110 0111
补码计算：
25+(-25) 0001 1001
+ 1110 0111
1 0000 0000
一个字节：
0000 0000 ->0
0000 0001 ->1
0111 1111 ->127 2的7次方-1
补码
1000 0001 -> -127
补码 1000 0001
反码：补码-1 1000 0000
原码：除符号位，取反1111 1111
1111 1111 --> -1
补码：1111 1111
反码：1111 1110
原码：1000 0001
1000 0000 本来 -0，但是-0浪费一种表示方式，因为-0和0 是一样，没必要用0000 0000和1000 0000两种表示方式。
-127 - 1 = -128
补码：1000 0001 - 0000 0001 = 1000 0000
*/
class TestJinZhi{
public static void main(String[] args){
System.out.println(0b10);
System.out.println(10);
System.out.println(010);
System.out.println(0 | [
"[email protected]"
] | |
191b3e7868f49f80db2d374573cb8308671809d8 | 211d02cafd56229949c88aa4146a54316a99b9dd | /src/main/java/com/nikita/kuzmichou/task/service/codes/CodesService.java | d19c085486ef2a87f64532a3d6844f02619debef | [] | no_license | NikitaKuzmichou/task | 55f1d9ef8e981503c92baacf1cf22d61b300af8d | af53e529272f5601d8ca391b9af69d096c0a67f6 | refs/heads/master | 2023-01-30T18:28:41.844277 | 2020-12-14T22:43:12 | 2020-12-14T22:43:12 | 320,061,814 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 670 | java | package com.nikita.kuzmichou.task.service.codes;
import org.springframework.stereotype.Service;
@Service
public class CodesService {
public Code getCodeByCodeStatus(CodeStatus status) {
switch (status) {
case OK:
return new Code(status, "OK");
case FIELD_UNDEFINED:
return new Code(status, "Name field undefined");
case ALREADY_STORED:
return new Code(status, "Entity already stored");
case NOT_FOUND:
return new Code(status, "Not found");
default:
return new Code(status, "Unknown status code");
}
}
}
| [
"[email protected]"
] | |
4602989546dba55eb95a1387544289f1ca1d2c50 | 214cbb376a18171da0c7137c617aae027955126e | /src/com/droidwolf/lua4android/MainActivity.java | c1c46bdf7e99c70707f0a888924c644850ff8127 | [] | no_license | tempbottle/lua4android | 2519b301a71fa39ec4c93c58163a07caf7f872e6 | 6301fdd9b84c0d401034d742f01b8b059e5498fa | refs/heads/master | 2021-01-13T16:24:23.308455 | 2014-07-27T07:08:24 | 2014-07-27T07:08:24 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 824 | java | package com.droidwolf.lua4android;
import org.keplerproject.luajava.LuaState;
import org.keplerproject.luajava.LuaStateFactory;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;
import android.support.v4.app.NavUtils;
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
LuaState L = LuaStateFactory.newLuaState();
L.openLibs();
L.LdoString("text = 'Hello Android, I am Lua.'");
L.getGlobal("text");
String text = L.toString(-1);
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
tv.setText(text);
setContentView(tv);
}
}
| [
"[email protected]"
] | |
b49b63ee88d6269bf47a6a727de3a251dc86133d | 89e7382d26c956557c4ab86d652f99b14251962e | /src/main/java/com/springboot/BookShop/controller/AppController.java | d26d862566a2842e578b6be75f654c3a6a54fd17 | [] | no_license | lumanhquan1999/BookShop | 5e5c2f94673290a17d3ebf3d2b749b1350f05150 | 2d9752fdaaa56941ae078cb89c18a56dfeaf31f2 | refs/heads/main | 2023-07-12T23:55:46.712367 | 2021-08-17T09:47:27 | 2021-08-17T09:47:27 | 388,479,053 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,110 | java | package com.springboot.BookShop.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import com.springboot.BookShop.utils.Utils;
@Controller
public class AppController {
@GetMapping("")
public String viewHomePage() {
return "index";
}
@GetMapping("/login")
public String showLoginPage(HttpServletRequest request) {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication == null || authentication instanceof AnonymousAuthenticationToken) {
Utils.removeCartInSession(request);
return "login";
}
return "redirect:/books/list";
}
// @PostMapping("/logout")
// public String logout() {
// SecurityContextHolder.getContext().setAuthentication(null);
//
// return "redirect:/books/list";
// }
}
| [
"[email protected]"
] | |
eb413a1b28ecfc46027d175d8f56295e076df655 | f21b12b2a515bfd2723372ff74b67ce9a73599ec | /ochre-api/src/main/java/gov/vha/isaac/ochre/api/coordinate/EditCoordinate.java | 18cffeda695ca7952ed42008a9b6767bb1d7d69b | [] | no_license | Apelon-VA/va-ochre | 44d0ee08a9bb6bb917efb36d8ba9093bad9fb216 | 677355de5a2a7f25fb59f08182633689075c7b93 | refs/heads/develop | 2020-12-24T14:00:41.848798 | 2015-10-01T07:20:00 | 2015-10-01T07:20:00 | 33,519,478 | 2 | 1 | null | 2015-06-26T14:14:18 | 2015-04-07T03:18:28 | Java | UTF-8 | Java | false | false | 781 | java | /*
* Copyright 2015 kec.
*
* 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 gov.vha.isaac.ochre.api.coordinate;
/**
*
* @author kec
*/
public interface EditCoordinate {
int getAuthorSequence();
int getModuleSequence();
int getPathSequence();
}
| [
"[email protected]"
] | |
8ccb8bf115c0992d6dfc31bec2df75806af5f701 | 76d7eb08bfd01978ffef7e9cae2bc50819f8e203 | /src/imult/BigInt.java | 357e92d1aee62466298ea000894a9817ad215d7d | [] | no_license | VincentSteil/Karatsuba-Offman-Algorithm | 38778340c6ab8e1bec331be3db735c89fafa57f2 | 41527005c0b2d39e742e82c31bb910a30d334d7b | refs/heads/master | 2021-01-01T18:29:14.733685 | 2013-02-08T21:10:09 | 2013-02-08T21:10:09 | 7,959,684 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 5,165 | java | package imult;
import java.lang.Math;
import java.util.Random;
import java.util.Scanner;
import java.util.InputMismatchException;
import java.lang.NullPointerException;
import java.util.List;
import java.util.Vector;
/*
* Class BigInt: Represents large positive integers in base = 10^4
* stored from least to most significant digits.
* (See coursework handout for full method documentation)
*/
public class BigInt {
private static final int power_ = 4; // base digit length
public static final int base_ = (int) Math.pow(10, power_); // base
public static final int MAX_LENGTH_ = 5000; // max digits
private Vector<Unsigned> digits_ = null;
private static Random rand = new Random();
public static Unsigned Zero_ = new Unsigned(0);
// constructors
public BigInt() { // init empty BigInt
digits_ = new Vector<Unsigned>();
}
public BigInt(int n) { // init with random digits
digits_ = new Vector<Unsigned>();
randomDigits(n);
}
public BigInt(String sval) { // init with digits in string
digits_ = new Vector<Unsigned>();
inputDigits(sval);
}
public BigInt(List<Unsigned> ivals) { // init with list of digits
digits_ = new Vector<Unsigned>(ivals);
}
public BigInt split(int r, int s) {
assert((0 <= r) && (r <= s));
while(s + 1 >= digits_.size())
digits_.add(Zero_);
return new BigInt(digits_.subList(r, s + 1));
}
public void setDigit(int index, Unsigned digit) {
assert(index < MAX_LENGTH_);
assert(digit.value() < base_);
if(index < digits_.size())
digits_.set(index, digit);
else
digits_.add(index, digit);
}
public Unsigned getDigit(int index) {
assert(index < MAX_LENGTH_);
if(index < digits_.size())
return digits_.get(index);
else
return Zero_;
}
public int length() {
// remove trailing zeroes
for(int i = digits_.size() - 1; i >= 0; i--) {
if(getDigit(i).value() == 0)
digits_.remove(i);
else break;
}
return digits_.size();
}
public void lshift(int n) {
assert(n >= 0);
/*for(int i = MAX_LENGTH_ - n; i < MAX_LENGTH_; i++) {
if(digits_.get(i).value() != 0) {
System.err.println("WARNING: shifting out nonzero digits in BigInt");
break;
}
}*/
for(int i = 0; i < n; i++) {
digits_.add(0, Zero_);
}
}
public void lshift(Unsigned n) {
this.lshift(n.intValue());
}
public void clear() {
digits_.clear();
}
public void randomDigits(int n) {
assert(n > 0 && n <= MAX_LENGTH_);
if(n >= MAX_LENGTH_ / 2) {
System.err.println("WARNING: Using a " + n + " digit BigInt may cause overflow when multiplied.");
}
this.clear(); // clear all current digits
for(int i = 0; i < n; i++) {
setDigit(i, new Unsigned(rand.nextInt(base_)));
}
if(getDigit(n - 1).value() == 0)
setDigit(n - 1, new Unsigned(1));
}
// TODO: MAKE SURE THIS METHOD THROWS ERRORS FOR ALL WRONG INPUT
public void inputDigits(String sval) {
this.clear(); // clear all current digits
Vector<Unsigned> vtmp = new Vector<Unsigned>();
// parse string for spaces
Scanner scan = new Scanner(sval);
while(scan.hasNext()) {
try {
int n = scan.nextInt();
if(n >= base_) {
System.err.println("ERROR: Digit " + n + " too large for base " + base_);
System.exit(1);
}
vtmp.add(new Unsigned(n));
}
catch(InputMismatchException e) {
System.err.println("ERROR: Invalid symbol while parsing digits \"" + scan.next() + "\"");
System.exit(1);
}
}
scan.close();
// store with lowest base digits first
int cnt = vtmp.size();
for(int i = 0; i < cnt; i++) {
setDigit(i, vtmp.get(cnt - i - 1));
}
if(this.length() >= MAX_LENGTH_ / 2)
System.err.println("WARNING: Using a " + this.length() + " digit BigInt may cause overflow when multiplied.");
}
public static int base() {
return base_;
}
public void print() {
// prints the BigInt as a integer
int len = this.length();
if(len == 0) {
System.out.println("0");
return;
}
for(int i = len - 1; i >= 0; i--) {
String zfill = "";
for(int j = power_ - 1; j > 0; j--) {
if(getDigit(i).value() < (long)Math.pow(10, j)) {
if(i < len - 1)
zfill += "0";
}
else break;
}
System.out.print(zfill + getDigit(i).value());
}
System.out.print("\n");
}
public void dump() {
// prints from least to most significant
// digits as stored.
int len = this.length();
for(int i = 0; i < len; i++)
System.err.print(digits_.get(i).value() + " | ");
System.err.print("\n");
}
public long value() {
// returns the long representation of this BigInt
long value = 0;
int len = this.length();
for(int i = 0; i < len; i++) {
value += digits_.get(i).value() * (long)Math.pow(base_, i);
}
return value;
}
public static void setRandSeed(long seed) {
rand.setSeed(seed);
}
public static void main(String argv[]) {
}
} //end class BigInt
| [
"[email protected]"
] | |
584866a30bce4a5513a5d51dffc6ee5e63a7275a | 42f9fab3cb393981b797d336624c38faddb73bad | /open-metadata-implementation/access-services/security-officer/security-officer-server/src/main/java/org/odpi/openmetadata/accessservices/securityofficer/server/admin/utils/Constants.java | 7a6750bd4826e2431aeee4f83349810596b2a3da | [
"CC-BY-4.0",
"Apache-2.0"
] | permissive | hfbbob/egeria | b7d2c412da3467861a696855dc011255382951be | 8ea5f1798993b619eb58483ec0a4dbc97f2f18d2 | refs/heads/master | 2020-06-01T07:58:55.736964 | 2019-06-05T09:16:04 | 2019-06-05T09:16:04 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 274 | java | /* SPDX-License-Identifier: Apache-2.0 */
/* Copyright Contributors to the ODPi Egeria project. */
package org.odpi.openmetadata.accessservices.securityofficer.server.admin.utils;
public class Constants {
public static final String SECURITY_TAG = "Confidentiality";
}
| [
"[email protected]"
] | |
6f976b8bb42a240a98771f2a577b915d50363fa4 | 559758d29fb04814b7ac20673e413922a0afec2e | /src/main/java/christopher/tutorial/init/BlockInit.java | 3531d594a097b9a89e4c8e3e3a600f4f3384d93b | [] | no_license | njsharpe/Mod-Update-2-with-New-Fence-and-Gate | 63e7047fc92a4626e52ffa7b9b0a29c75fb9e058 | e2f456505d95b5caf178b1b9f3a3adb4b1fccf7c | refs/heads/master | 2021-09-08T06:24:31.885389 | 2017-08-24T03:04:25 | 2017-08-24T03:04:25 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,976 | java | package christopher.tutorial.init;
import christopher.tutorial.init.blocks.DiamondBrick;
import christopher.tutorial.init.blocks.DiamondBrickStairs;
import christopher.tutorial.Reference;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.ItemMeshDefinition;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.fml.common.registry.ForgeRegistries;
public class BlockInit
{
public static DiamondBrick diamond_brick;
public static DiamondBrickStairs diamond_brick_stairs;
public static void init()
{
diamond_brick = new DiamondBrick("diamond_brick", 45.0F, 25000000.0F, 3);
diamond_brick_stairs = new DiamondBrickStairs("diamond_brick_stairs", diamond_brick.getDefaultState());
}
public static void register()
{
registerBlock(diamond_brick);
registerBlock(diamond_brick_stairs);
}
public static void registerBlock(Block block)
{
ForgeRegistries.BLOCKS.register(block);
block.setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
ItemBlock item = new ItemBlock(block);
item.setRegistryName(block.getRegistryName());
ForgeRegistries.ITEMS.register(item);
ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(block), 0, new ModelResourceLocation(block.getRegistryName(), "inventory"));
}
public static void registerBlock(Block block, ItemBlock itemblock)
{
ForgeRegistries.BLOCKS.register(block);
block.setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
itemblock.setRegistryName(block.getRegistryName());
ForgeRegistries.ITEMS.register(itemblock);
ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(block), 0, new ModelResourceLocation(block.getRegistryName(), "inventory"));
}
}
| [
"[email protected]"
] | |
3f55713b5471550347ebe01c30c74897d496cc35 | 7a8c14d6400190fff9304f4cf2f588f6132d9b95 | /NUTRICAO/src/main/java/com/iala/cpd/type/TipoRefeicao.java | 3acfc10b35d4ca1255353a43c164bb74e16e3eda | [] | no_license | cpd-info/nutedusys | 7f12135fb89bb29883eacafaa416a89649d2f6e1 | 6fbb542c1256688089b46ccad97099fae6099034 | refs/heads/master | 2023-08-18T05:11:11.199014 | 2020-06-27T17:37:50 | 2020-06-27T17:37:50 | 205,380,978 | 0 | 0 | null | 2023-06-27T22:06:25 | 2019-08-30T12:47:34 | JavaScript | UTF-8 | Java | false | false | 323 | java | package com.iala.cpd.type;
public enum TipoRefeicao {
DESEJUM, ALMOCO, LANCHE, JANTA;
private final String text;
TipoRefeicao(String text) {
this.text = text;
}
TipoRefeicao() {
this.text="";
}
public String defString() {
return (text == "") ? this.toString() : text;
}
} | [
"Leandro@DESKTOP-84NF5B0"
] | Leandro@DESKTOP-84NF5B0 |
c1ef7469cb490a16d642128c6753f3221cb0b845 | affb2c0e5b07c852a463725a628641a1b65a56ca | /src/main/java/cmm/javacc/zck/CMMParserTreeConstants.java | 1a633f66b6f251fff71bff125c8445981cc2a7c9 | [] | no_license | zhangchengkai826/cmm-javacc-zck | 05331c324951ef60d4ee2470c160902e2f1f4fc3 | 713e9926ceae804cbfc8446e1141c75de3af2b74 | refs/heads/master | 2022-03-27T12:48:37.833407 | 2019-12-26T01:52:15 | 2019-12-26T01:52:15 | 230,184,605 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,808 | java | /* Generated By:JavaCC: Do not edit this line. CMMParserTreeConstants.java Version 5.0 */
package cmm.javacc.zck;
public interface CMMParserTreeConstants
{
public int JJTSENTENCES = 0;
public int JJTEMPTY = 1;
public int JJTSENTENCE = 2;
public int JJTFUNCPARAMBRACKETEXPR = 3;
public int JJTFUNCPARAMCOMMAEXPR = 4;
public int JJTFUNCPARAMEXPR = 5;
public int JJTDECLCOMMAEXPR = 6;
public int JJTDECLEXPR = 7;
public int JJTTYPE = 8;
public int JJTLITERAL = 9;
public int JJTCOMMAEXPR = 10;
public int JJTASSIGNEXPR = 11;
public int JJTLOGICOREXPR = 12;
public int JJTLOGICANDEXPR = 13;
public int JJTBITOREXPR = 14;
public int JJTBITEXOREXPR = 15;
public int JJTBITANDEXPR = 16;
public int JJTRELEXPR = 17;
public int JJTRELOP = 18;
public int JJTADDSUBEXPR = 19;
public int JJTADDSUBOP = 20;
public int JJTMULDIVEXPR = 21;
public int JJTMULDIVOP = 22;
public int JJTUNARYEXPR = 23;
public int JJTUNARYOP = 24;
public int JJTPOSTUNARYEXPR = 25;
public int JJTPOSTUNARYOP = 26;
public int JJTBRACKETEXPR = 27;
public int JJTDECLVAREXPR = 28;
public int JJTDECLVARARRFUNCEXPR = 29;
public int JJTDECLVARBRACKETEXPR = 30;
public int JJTDECLTYPEEXPR = 31;
public int JJTDECLTYPEARRFUNCEXPR = 32;
public int JJTDECLTYPEBRACKETEXPR = 33;
public int JJTSENTENCES_ = 34;
public int JJTSENTENCE_ = 35;
public int JJTFUNCPARAMBRACKETEXPR_ = 36;
public int JJTFUNCPARAMCOMMAEXPR_ = 37;
public int JJTFUNCPARAMEXPR_ = 38;
public int JJTDECLCOMMAEXPR_ = 39;
public int JJTDECLEXPR_ = 40;
public int JJTTYPE_ = 41;
public int JJTLITERAL_ = 42;
public int JJTCOMMAEXPR_ = 43;
public int JJTASSIGNEXPR_ = 44;
public int JJTLOGICOREXPR_ = 45;
public int JJTLOGICANDEXPR_ = 46;
public int JJTBITOREXPR_ = 47;
public int JJTBITEXOREXPR_ = 48;
public int JJTBITANDEXPR_ = 49;
public int JJTRELEXPR_ = 50;
public int JJTRELOP_ = 51;
public int JJTADDSUBEXPR_ = 52;
public int JJTADDSUBOP_ = 53;
public int JJTMULDIVEXPR_ = 54;
public int JJTMULDIVOP_ = 55;
public int JJTUNARYEXPR_ = 56;
public int JJTUNARYOP_ = 57;
public int JJTPOSTUNARYEXPR_ = 58;
public int JJTPOSTUNARYOP_ = 59;
public int JJTBRACKETEXPR_ = 60;
public int JJTDECLVAREXPR_ = 61;
public int JJTDECLVARARRFUNCEXPR_ = 62;
public int JJTDECLVARBRACKETEXPR_ = 63;
public int JJTDECLTYPEEXPR_ = 64;
public int JJTDECLTYPEARRFUNCEXPR_ = 65;
public int JJTDECLTYPEBRACKETEXPR_ = 66;
public int JJTIF = 67;
public int JJTELSE = 68;
public int JJTWHILE = 69;
public int JJTBREAK = 70;
public int JJTCONTINUE = 71;
public int JJTRETURN = 72;
public int JJTINT = 73;
public int JJTREAL = 74;
public int JJTCHAR = 75;
public int JJTVOID = 76;
public int JJTLCB = 77;
public int JJTRCB = 78;
public int JJTSEMI = 79;
public int JJTLRB = 80;
public int JJTRRB = 81;
public int JJTASN = 82;
public int JJTLSB = 83;
public int JJTRSB = 84;
public int JJTLT = 85;
public int JJTLTE = 86;
public int JJTEQ = 87;
public int JJTNEQ = 88;
public int JJTGT = 89;
public int JJTGTE = 90;
public int JJTADD = 91;
public int JJTSUB = 92;
public int JJTMUL = 93;
public int JJTDIV = 94;
public int JJTCMMA = 95;
public int JJTLAND = 96;
public int JJTBAND = 97;
public int JJTLOR = 98;
public int JJTBOR = 99;
public int JJTBXOR = 100;
public int JJTLNT = 101;
public int JJTBNT = 102;
public int JJTDEC = 103;
public int JJTINC = 104;
public int JJTMOD = 105;
public int JJTILT = 106;
public int JJTRLT = 107;
public int JJTCLT = 108;
public int JJTSLT = 109;
public int JJTID = 110;
public String[] jjtNodeName = {
"Sentences",
"Empty",
"Sentence",
"FuncParamBracketExpr",
"FuncParamCommaExpr",
"FuncParamExpr",
"DeclCommaExpr",
"DeclExpr",
"Type",
"Literal",
"CommaExpr",
"AssignExpr",
"LogicOrExpr",
"LogicAndExpr",
"BitOrExpr",
"BitExOrExpr",
"BitAndExpr",
"RelExpr",
"RelOp",
"AddSubExpr",
"AddSubOp",
"MulDivExpr",
"MulDivOp",
"UnaryExpr",
"UnaryOp",
"PostUnaryExpr",
"PostUnaryOp",
"BracketExpr",
"DeclVarExpr",
"DeclVarArrFuncExpr",
"DeclVarBracketExpr",
"DeclTypeExpr",
"DeclTypeArrFuncExpr",
"DeclTypeBracketExpr",
"Sentences_",
"Sentence_",
"FuncParamBracketExpr_",
"FuncParamCommaExpr_",
"FuncParamExpr_",
"DeclCommaExpr_",
"DeclExpr_",
"Type_",
"Literal_",
"CommaExpr_",
"AssignExpr_",
"LogicOrExpr_",
"LogicAndExpr_",
"BitOrExpr_",
"BitExOrExpr_",
"BitAndExpr_",
"RelExpr_",
"RelOp_",
"AddSubExpr_",
"AddSubOp_",
"MulDivExpr_",
"MulDivOp_",
"UnaryExpr_",
"UnaryOp_",
"PostUnaryExpr_",
"PostUnaryOp_",
"BracketExpr_",
"DeclVarExpr_",
"DeclVarArrFuncExpr_",
"DeclVarBracketExpr_",
"DeclTypeExpr_",
"DeclTypeArrFuncExpr_",
"DeclTypeBracketExpr_",
"IF",
"ELSE",
"WHILE",
"BREAK",
"CONTINUE",
"RETURN",
"INT",
"REAL",
"CHAR",
"VOID",
"LCB",
"RCB",
"SEMI",
"LRB",
"RRB",
"ASN",
"LSB",
"RSB",
"LT",
"LTE",
"EQ",
"NEQ",
"GT",
"GTE",
"ADD",
"SUB",
"MUL",
"DIV",
"CMMA",
"LAND",
"BAND",
"LOR",
"BOR",
"BXOR",
"LNT",
"BNT",
"DEC",
"INC",
"MOD",
"ILT",
"RLT",
"CLT",
"SLT",
"ID",
};
}
/* JavaCC - OriginalChecksum=2160690f636945df978d1f8d1bb0ea63 (do not edit this line) */
| [
"[email protected]"
] | |
0f5b6434554c3a9ce52152eacf9ee4d260bb970c | 356efad893c9e8eadbcd921c93c4db03d7fe72a5 | /src/org/ictclas4j/bean/SegNode.java | 41b0797d49343358d3c8f8198efe4d4e386324ae | [] | no_license | ggxyjs/weiboFetch | 9a812652d5cd8f7c7f439a26c1b3f9ab69d78e98 | 76f16926df194f45bccf2334df078ace0b8eb934 | refs/heads/master | 2021-01-10T11:23:12.631848 | 2016-01-22T06:34:05 | 2016-01-22T06:34:05 | 50,160,341 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 2,418 | java | package org.ictclas4j.bean;
import java.util.ArrayList;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.ictclas4j.utility.Utility;
/**
* 分词图表中的节点，实际表示图中的一条边
*
* @author sinboy
*
*/
public class SegNode implements Cloneable {
private int col;// 表示边的后驱，即终点
private int row;// 表示边的前驱，即起点
private double value;// 词频值
private int pos;// 词性
private ArrayList<POS> allPos;// 词性，一个词可能对应多个词性
private String word;// 边的内容，可能有这样的表示形式：末＃＃数、末＃＃时等
private String srcWord;// 分词前对应的原始内容
public SegNode() {
}
public SegNode(int row, int col, int pos, double value, String word) {
this.row = row;
this.col = col;
this.pos = pos;
this.value = value;
setWord(word);
}
public int getCol() {
return col;
}
public void setCol(int col) {
this.col = col;
}
public int getLen() {
return srcWord != null ? srcWord.getBytes().length : -1;
}
public int getPos() {
return pos;
}
public void setPos(int pos) {
this.pos = pos;
}
public void addPos(POS pos) {
if (allPos == null)
allPos = new ArrayList<POS>();
this.allPos.add(pos);
}
public ArrayList<POS> getAllPos() {
return allPos;
}
public void setAllPos(ArrayList<POS> posList) {
this.allPos = posList;
}
public int getPosSize() {
return allPos != null ? allPos.size() : -1;
}
public int getRow() {
return row;
}
public void setRow(int row) {
this.row = row;
}
public String getWord() {
return word;
}
public void appendWord(String word) {
if (this.word == null)
this.word = word;
else
this.word += word;
setWord(word);
}
public void setWord(String word) {
this.word = word;
if (!Utility.isUnknownWord(word))
this.srcWord = word;
}
public String getSrcWord() {
return srcWord;
}
public void setSrcWord(String srcWord) {
this.srcWord = srcWord;
}
public double getValue() {
return value;
}
public void setValue(double value) {
this.value = value;
}
public String toString() {
return ReflectionToStringBuilder.toString(this);
}
public SegNode clone() {
SegNode result = null;
try {
result = (SegNode) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return result;
}
}
| [
"[email protected]"
] | |
6536c23ce283e6fab6ddfb0798873c79fe2a1042 | 8c93d4a7f51c0718e0f2111e025e1391a138ecfa | /corpus/src/main/java/com/velik/recommend/factory/PersonNameCorpusFactory.java | 01893c8f30c7cf983f6c246acf0035d8896ec104 | [] | no_license | ehrencrona/visitor-map | bed42201c08358dfa4bcd7493ebfdec5c0f7a0c4 | e5138a1d8f8e41316efcda75da8977b94c8d464c | refs/heads/master | 2021-06-10T10:36:10.969296 | 2012-09-14T16:20:21 | 2012-09-14T16:20:21 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,440 | java | package com.velik.recommend.factory;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import com.velik.recommend.corpus.Article;
import com.velik.recommend.corpus.ArticleVisitor;
import com.velik.recommend.corpus.NameFindingVisitor;
import com.velik.recommend.corpus.NameFindingVisitor.PotentialName;
import com.velik.recommend.corpus.NoSuchWordException;
import com.velik.recommend.corpus.PersonNames;
import com.velik.recommend.corpus.WordSet;
public class PersonNameCorpusFactory {
public PersonNames create(final Context context) {
System.out.println("Computing person names...");
final PersonNames result = new PersonNames();
WordSet firsts = result.firsts;
WordSet middles = result.middles;
WordSet lasts = result.lasts;
WordSet titles = result.titles;
for (String word : new String[] { "al", "auf dem", "auf'm", "aus dem", "aus der", "d", "e", "da", "de", "del",
"los", "las", "den", "der", "di", "do", "dos", "du", "el", "la", "lo", "ten", "ter", "van", "von",
"von de", "von", "y", "zur", "zu", "ibn" }) {
titles.add(word);
}
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File(
"../spider/names.txt")), "UTF-8"));
String line;
while ((line = reader.readLine()) != null) {
int j = line.indexOf(',');
if (j > 0) {
line = line.substring(0, j);
}
if (hasSpecialCharacters(line)) {
continue;
}
int i = line.indexOf(" --- ");
if (i > 0) {
line = line.substring(0, i) + line.substring(i + 4);
}
String firstAndMiddle = null;
String last = null;
i = line.lastIndexOf(" ");
if (i > 0) {
last = line.substring(i + 1);
firstAndMiddle = line.substring(0, i);
}
if (firstAndMiddle != null && last != null) {
String[] components = last.split("[ \\.-]");
for (String lastPart : components) {
if (lastPart.equals("")) {
continue;
}
if (lastPart.length() > 3 && Character.isUpperCase(lastPart.charAt(0))
&& !isEntirelyUppercase(lastPart)) {
lasts.add(lastPart);
}
}
boolean first = true;
for (String firstOrMiddlePart : firstAndMiddle.split("[ \\.-]")) {
if (firstOrMiddlePart.length() > 2 && Character.isUpperCase(firstOrMiddlePart.charAt(0))
&& !isEntirelyUppercase(firstOrMiddlePart)) {
if (first) {
firsts.add(firstOrMiddlePart);
first = false;
} else {
middles.add(firstOrMiddlePart);
}
}
}
}
}
reader.close();
final Map<String, Integer> countByFullName = new HashMap<String, Integer>();
final NameFindingVisitor delegate = new NameFindingVisitor(context.getNouns(), result);
context.visit(new ArticleVisitor() {
private int articleCount = 0;
@Override
public void processArticle(Article article) {
if (articleCount++ % 10000 == 9999) {
System.out.println(articleCount + " articles...");
}
delegate.processArticle(article);
for (PotentialName name : delegate.getPotentialNames()) {
String fullName = name.getFullName();
Integer count = countByFullName.get(fullName);
if (count == null) {
count = 1;
} else {
count = count + 1;
}
countByFullName.put(fullName, count);
}
}
});
delegate.done();
for (Entry<String, Integer> entry : countByFullName.entrySet()) {
System.out.println(entry);
if (entry.getValue() < 5) {
continue;
}
String fullName = entry.getKey();
try {
String[] components = fullName.split(" ");
List<Integer> indexes = new ArrayList<Integer>();
for (int i = 0; i < components.length; i++) {
String component = components[i];
for (String subComponent : component.split("-")) {
try {
indexes.add(result.titles.indexOf(subComponent));
} catch (NoSuchWordException e) {
if (i == 0) {
indexes.add(result.firsts.indexOf(subComponent));
} else if (i == components.length - 1) {
indexes.add(result.lasts.indexOf(subComponent));
} else {
indexes.add(result.middles.indexOf(subComponent));
}
}
}
}
result.full.add(toIntArray(indexes));
} catch (NoSuchWordException e) {
// next. don't pollute the name lists
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Done.");
return result;
}
private int[] toIntArray(List<Integer> indexes) {
int[] result = new int[indexes.size()];
for (int i = 0; i < indexes.size(); i++) {
result[i] = indexes.get(i);
}
return result;
}
private boolean hasSpecialCharacters(String line) {
for (int i = 0; i < line.length(); i++) {
char ch = line.charAt(i);
if (ch != ' ' && ch != '.' && ch != '-' && !Character.isLetter(ch)) {
return true;
}
}
return false;
}
private boolean isEntirelyUppercase(String string) {
for (int i = 0; i < string.length(); i++) {
if (!Character.isUpperCase(string.charAt(i))) {
return false;
}
}
return true;
}
}
| [
"[email protected]"
] | |
fec1933fa096ecaad425c8f1aa7960c54e68c34a | 53950512b46acf3d0a42e10b98fd88cda1864184 | /Tuple.java | d75edf6c4f8c8bbde281cdad255acdad3d2e9700 | [
"MIT"
] | permissive | leddy231/JavaEngine | 76f5b6eed6008170a62c44d2a72fa32c545ef8ac | ef47b918f55d179d22294dac626c03b986cb2d15 | refs/heads/master | 2022-03-30T14:29:28.494884 | 2020-01-30T14:41:58 | 2020-01-30T14:41:58 | 187,178,483 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 332 | java | public class Tuple<T> {
public T obj1;
public T obj2;
public boolean isEmpty;
public Tuple(T obj1, T obj2) {
this.obj1 = obj1;
this.obj2 = obj2;
}
private Tuple() {
isEmpty = true;
}
public static <T> Tuple<T> empty() {
return new Tuple<T>();
}
} | [
"[email protected]"
] | |
02fd66aa25a6e2d496b46ac54e15006b40c4de0f | f09836a76809d077570502ed29047dbd4909688c | /minibox-service/src/main/java/com/ghw/minibox/controller/MbpUserController.java | cb064acebe4cba336c4ad5434b7fb58eb0a200e8 | [] | no_license | VioletCoding/mini-box | 0f92179eecae367398d14889d2d3ff80a9f493a9 | f066fa8ebb82c19d9f2698dff59bb801bafcdf95 | refs/heads/master | 2023-04-11T17:40:10.593050 | 2021-04-23T12:05:41 | 2021-04-23T12:05:41 | 313,925,064 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,990 | java | package com.ghw.minibox.controller;
import com.ghw.minibox.model.CommentModel;
import com.ghw.minibox.model.PostModel;
import com.ghw.minibox.model.UserModel;
import com.ghw.minibox.service.MbpUserService;
import com.ghw.minibox.utils.Result;
import com.ghw.minibox.vo.ResultVo;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* @author Violet
* @description 用户 控制层
* @date 2021/1/31
*/
@RestController
@RequestMapping("userApi")
public class MbpUserController {
@Resource
private MbpUserService userService;
/**
* 用户个人信息
*
* @param id 用户id
* @return 用户个人信息
*/
@GetMapping("userInfo")
public ResultVo userInfo(@RequestParam Long id) {
UserModel userModel = userService.findUserDetail(id);
return Result.success(userModel);
}
/**
* 用户信息修改
*
* @param userModel 实体
* @return 修改后的用户信息
*/
@PostMapping("userModify")
public ResultVo userModify(@RequestBody UserModel userModel) {
UserModel updateUserInfo = userService.updateUserInfo(userModel);
return Result.success(updateUserInfo);
}
/**
* 查询该用户发表过的所有帖子
*
* @param id 用户id
* @return 用户发表过的所有帖子的详细信息
*/
@GetMapping("userPosts")
public ResultVo userPosts(@RequestParam Long id) {
List<PostModel> userAllPost = userService.findUserAllPost(id);
return Result.success(userAllPost);
}
/**
* 查询该用户发表过的所有评论
*
* @param id 用户id
* @return 用户发表过的所有评论，以及评论在哪个地方发表的
*/
@GetMapping("userComments")
public ResultVo userComments(@RequestParam Long id) {
List<CommentModel> userAllComment = userService.findUserAllComment(id);
return Result.success(userAllComment);
}
/**
* 修改用户的密码
*
* @param userModel 实体，传id和password
* @return 是否成功
*/
@PostMapping("userPwdModify")
public ResultVo userPwdModify(@RequestBody UserModel userModel) {
boolean b = userService.updatePassword(userModel.getId(), userModel.getPassword());
return Result.successFlag(b);
}
/**
* 用户列表
*
* @param userModel 实体
* @return 用户列表
*/
@PostMapping("list")
public ResultVo userList(@RequestBody(required = false) UserModel userModel) {
List<UserModel> userModels = userService.userList(userModel);
return Result.success(userModels);
}
/**
* 查找用户以及每个用户的所有角色
*
* @param userModel 实例
* @return 列表
*/
@PostMapping("withRoles")
public ResultVo userListWithRoles(@RequestBody(required = false) UserModel userModel) {
List<UserModel> userModels = userService.userListWithRoles(userModel);
return Result.success(userModels);
}
/**
* 赋予用户管理员角色
*
* @param id 用户id
* @return 用户列表
*/
@GetMapping("addAdmin")
public ResultVo addUserAdmin(@RequestParam Long id) {
boolean b = userService.addUserAdminRole(id);
return Result.successFlag(b);
}
/**
* 删除用户管理员角色
*
* @param id 用户id
* @return 用户列表
*/
@GetMapping("deleteAdmin")
public ResultVo deleteUserRoles(@RequestParam Long id) {
boolean b = userService.deleteUserAdmin(id);
return Result.successFlag(b);
}
/**
* 删除用户
*
* @param id 用户id
* @return 用户列表
*/
@GetMapping("delete")
public ResultVo deleteUser(@RequestParam Long id) {
List<UserModel> userModels = userService.deleteUser(id);
return Result.success(userModels);
}
}
| [
"[email protected]"
] | |
a5823a25159b5d51b7f21b73ff50bf3c2a563de8 | 822b57513f771ee30bc17fc879b592d134e05873 | /Hands-on programs/Day-3/MethodOverloading2.java | c1ed5a37be2322fb695a1c036136fa4b48c291c4 | [] | no_license | ThangabarathT/OneBill-Training | 28a1f0c3e48757ab16afa3279a8f97186e08dbc8 | 8e30cf4e30dc9e0d67f4e3756a732c5ecc7a89d0 | refs/heads/master | 2023-06-23T08:14:45.564485 | 2021-07-05T05:08:05 | 2021-07-05T05:08:05 | 370,036,884 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 910 | java | /* Example program for Method Overloading
*
* Method overloading is a feature of Java in which a class has more
* than one method of the same name and their parameters are different.
*
* Method Overloading - Vary the type of parameter
*
* */
package com.onebill.corejava.basic;
/**
* @author T. THANGABARATH
* @version
*/
/** Create a new Constructor - Overload2 */
class Overload2 {
/** Method have char type parameter */
public void display(char c) {
System.out.println("Method have char type parameter");
}
/** Method have int type parameter */
public void display(int a) {
System.out.println("Method have int type parameter");
}
}
public class MethodOverloading2 {
public static void main(String[] args) {
Overload2 obj = new Overload2();
obj.display('a'); // Invoke the method with char type argument
obj.display(10); // Invoke the method with int type argument
}
}
| [
"[email protected]"
] | |
0f176c0686cf31e8af8263413aeecad0ced1634f | 9a2d885bf748bb25bdf8895e301781de3b5b147d | /Tianji/src/com/utils/tools/AnimationManager.java | 4ef0aa9e5a79ba05c33bd993b5358f3a11a98fef | [] | no_license | Jisucloud/android | 918215138ed4b558eb32ee61d89b6cbd046cf414 | ae886daf4a29f9e46612a58197abb2f4895c0fbc | refs/heads/master | 2023-03-19T22:26:54.391865 | 2017-04-11T07:26:09 | 2017-04-11T07:26:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,883 | java | package com.utils.tools;
import android.R.integer;
import android.view.View;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.RotateAnimation;
import android.view.animation.Animation.AnimationListener;
public class AnimationManager {
/**
*
* View渐隐动画效果
*
*
*/
public static void setHideAnimation(View view, int duration,
AnimationListener listener) {
if (null == view || duration < 0) {
return;
}
AlphaAnimation mHideAnimation = new AlphaAnimation(1.0f, 0.0f);
mHideAnimation.setDuration(duration);
mHideAnimation.setFillAfter(true);
if (listener != null) {
mHideAnimation.setAnimationListener(listener);
}
view.startAnimation(mHideAnimation);
}
/**
*
* View渐现动画效果
*
*
*/
public static void setShowAnimation(View view, int duration,
AnimationListener listener) {
if (null == view || duration < 0) {
return;
}
AlphaAnimation mShowAnimation = new AlphaAnimation(0.0f, 1.0f);
mShowAnimation.setDuration(duration);
mShowAnimation.setFillAfter(true);
if (listener != null) {
mShowAnimation.setAnimationListener(listener);
}
view.startAnimation(mShowAnimation);
}
public static void setRotateAnimation(View view, int fromDegree, int toDegree, int duration, int repeatCount,
AnimationListener listener){
RotateAnimation rotateAnimation = new RotateAnimation(fromDegree, toDegree,Animation.RELATIVE_TO_SELF,
0.5f,Animation.RELATIVE_TO_SELF,0.5f);
rotateAnimation.setDuration(duration);
rotateAnimation.setFillAfter(true);
rotateAnimation.setRepeatCount(repeatCount);
if (listener != null) {
rotateAnimation.setAnimationListener(listener);
}
view.startAnimation(rotateAnimation);
}
}
| [
"[email protected]"
] | |
816c5e97384649f1ad27688637437ab3e4a53c7c | b1c13602d86031daf1cd124f63e010c8f7edff82 | /app/src/main/java/org/t_robop/masatsuna/sample/MainActivity.java | 7a957bc072181ada5ccaa71317a69253c35ef070 | [] | no_license | Masatsuna/sample | 66475a158154ea8bf142e05aa0d55678e9cf32b5 | f4aa671e434ce519bfa4a95e97e06a271e03960c | refs/heads/master | 2021-01-20T19:26:04.219701 | 2016-06-03T12:32:32 | 2016-06-03T12:32:32 | 60,344,967 | 0 | 0 | null | 2016-06-03T12:32:33 | 2016-06-03T12:09:31 | Java | UTF-8 | Java | false | false | 341 | java | package org.t_robop.masatsuna.sample;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
| [
"CloQuespayl6"
] | CloQuespayl6 |
416c03f9bf4f29d842ace9e12978722f602f699e | 9fdbca757e88cd89539b4f23d94cd2b59e3eaf4f | /src/com/pp/bean/Question.java | b0907a9e94fd7821a1ccce2b072b65193ffec5b2 | [] | no_license | Stephaniefan/PrivacyProject | fe4d8d7cc3b7e9c4a0e50165910a6472cfecfba6 | 9b0652053baf3d43d4ba7632d551c39550d10327 | refs/heads/master | 2021-01-10T15:46:31.299665 | 2015-05-29T03:32:01 | 2015-05-29T03:32:01 | 36,335,114 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 324 | java | package com.pp.bean;
public class Question {
public String id;
public String title;
public String ans;
public Question(String id, String title, String ans){
this.id = id;
this.title = title;
this.ans = ans;
}
public String toString(){
return "id:"+this.id+" title:"+this.title+" ans:"+this.ans;
}
}
| [
"[email protected]"
] | |
4db8ec6274b9750b3d768c7937e71878e6bfbd66 | d8820ee8039188a06eb2472eef2a8f825467521e | /src/main/java/com/locusxt/app/domain/NewRule.java | 79c19f9772c27090a64b4d9392613360fe2ec558 | [] | no_license | locusxt/diagnosis_spring | 6018b35aaddaff2d35730c54d07e9b20d64adc40 | 722b8b6a08351e14fb5cdbe2a3961bc7b943cf14 | refs/heads/master | 2020-06-04T17:47:43.153495 | 2015-08-07T08:46:53 | 2015-08-07T08:46:53 | 38,957,751 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,479 | java | package com.locusxt.app.domain;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
public class NewRule {
String[] rules;
String[] comments;
String targetFile;
public void setRules(String[] rules){
this.rules = rules;
}
public String[] getRules(){
return this.rules;
}
public void setComments(String[] comments){
this.comments = comments;
}
public String[] getComments(){
return this.comments;
}
public void save(){
File f1 = new File(targetFile);
File f2 = new File(targetFile + ".comment");
FileWriter fw1 = null;
FileWriter fw2 = null;
BufferedWriter bw1 = null;
BufferedWriter bw2 = null;
int num = rules.length;
try{
fw1 = new FileWriter(f1, true);
bw1 = new BufferedWriter(fw1);
fw2 = new FileWriter(f2, true);
bw2 = new BufferedWriter(fw2);
for (int i = 0; i < num; ++i){
bw1.write(this.rules[i]);
bw1.newLine();
bw2.write(this.comments[i]);
bw2.newLine();
}
bw1.flush();
bw2.flush();
}
catch (FileNotFoundException e){
e.printStackTrace();
}
catch (IOException e){
e.printStackTrace();
}
finally{
try{
bw1.close();
bw2.close();
fw1.close();
fw2.close();
}
catch (IOException e){
e.printStackTrace();
}
}
}
public NewRule(){
this.targetFile = "a.rules";
}
public NewRule(String targetFile){
this.targetFile = targetFile;
}
}
| [
"[email protected]"
] | |
88bb07d0ed922496c2d003f50233402e31209ba1 | f0688082baedc4b02744b41e859dfaeff3bf60a3 | /src/main/java/com/abk/fn_scintilla/Predicate.java | f8e10dbe05c487605f0ecdec79973486094b132c | [
"MIT"
] | permissive | kgilmer/fn_scintilla | da717c7a4a30f6de48810f2bb0ffacdfd052ef7d | 7a79bb41f5d55a3cb0712fdad3d96774ae1574e2 | refs/heads/master | 2021-01-01T17:39:29.557913 | 2017-07-23T20:43:52 | 2017-07-23T20:43:52 | 98,123,837 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 199 | java | package com.abk.fn_scintilla;
/**
* Created from https://stackoverflow.com/questions/22905562/functional-interfaces-of-java-8-in-java-7
*/
public interface Predicate<T> {
boolean test(T t);
}
| [
"[email protected]"
] | |
bb7bb53d47191d81a24d584a9bdafdeaba01adfc | e9d31535692b1630bbe4003060e0a7ab64144b1a | /src/myhilo/LoginForm.java | 8a255fb212f356ea813b7442449fa0d635a53fc1 | [] | no_license | darmonlyone/MyHighLowGame | 6c7ac6da4031dcec5def04e72fa868378fa61a4c | eb90ba4a22043cacd17c48ec806707eb35d37adb | refs/heads/master | 2021-08-29T23:12:39.353338 | 2017-12-15T07:42:05 | 2017-12-15T07:42:05 | 112,193,693 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,138 | 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 myhilo;
import java.util.List;
import java.awt.Color;
import java.awt.event.*;
import java.io.PrintStream;
/**
* Login form use for login to play on Hilo Game with your own account.
*
* @author Manusporn Fukkham
*/
public class LoginForm extends javax.swing.JFrame {
/**
* Creates new form login
*/
public static List<String> username;
public static List<String> password;
public static List<Integer> userMoney;
public FileSet file = new FileSet();
public LoginForm() {
initComponents();
setSize(500, 500);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocationRelativeTo(null);
}
public void runLogin(){
PasswordSolve solvePassword = new PasswordSolve();
String userLogin = userText.getText();
String passLogin = passwordGetText.getText();
file.setUPM();
username = file.getUsername();
password = file.getPassword();
userMoney = file.getUserMoney();
PrintStream logSave = new PrintStream(file.getOutputStreamNewFile());
for (int i = 0 ; i < username.size(); i++){
if (userLogin.equals(username.get(i))&&solvePassword.verifyPassword(passLogin, password.get(i))){
logSave.print(username.get(i));
StartForm start = new StartForm();
username.clear();
start.setVisible(true);
start.fileOpen();
this.setVisible(false);
file.setAllListClear();
logSave.close();
break;
}else{
wrong.setForeground(Color.RED);
}
}
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
wrong = new javax.swing.JTextField();
userText = new javax.swing.JTextField();
goRegister = new javax.swing.JTextField();
loginButt = new javax.swing.JButton();
cancelButt = new javax.swing.JButton();
passwordGetText = new javax.swing.JPasswordField();
background = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
getContentPane().setLayout(new org.netbeans.lib.awtextra.AbsoluteLayout());
wrong.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
wrong.setForeground(new java.awt.Color(255, 255, 255));
wrong.setText("Wrong username or password");
wrong.setBorder(null);
wrong.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
wrong.setFocusable(false);
getContentPane().add(wrong, new org.netbeans.lib.awtextra.AbsoluteConstraints(90, 140, -1, -1));
userText.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
userText.setForeground(new java.awt.Color(204, 204, 204));
userText.setText("username");
userText.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
userTextMouseClicked(evt);
}
});
userText.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
userTextKeyPressed(evt);
}
public void keyTyped(java.awt.event.KeyEvent evt) {
userTextKeyTyped(evt);
}
});
getContentPane().add(userText, new org.netbeans.lib.awtextra.AbsoluteConstraints(170, 200, 270, 40));
goRegister.setFont(new java.awt.Font("Tahoma", 0, 18)); // NOI18N
goRegister.setForeground(new java.awt.Color(102, 51, 255));
goRegister.setText("Click here to create new account");
goRegister.setToolTipText("");
goRegister.setBorder(null);
goRegister.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
goRegister.setFocusable(false);
goRegister.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
goRegisterMouseClicked(evt);
}
});
getContentPane().add(goRegister, new org.netbeans.lib.awtextra.AbsoluteConstraints(140, 430, -1, -1));
loginButt.setBackground(new java.awt.Color(102, 102, 255));
loginButt.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
loginButt.setForeground(new java.awt.Color(255, 255, 255));
loginButt.setText("Login");
loginButt.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
loginButt.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
loginButtActionPerformed(evt);
}
});
getContentPane().add(loginButt, new org.netbeans.lib.awtextra.AbsoluteConstraints(120, 330, 120, 70));
cancelButt.setBackground(new java.awt.Color(255, 51, 51));
cancelButt.setFont(new java.awt.Font("Tahoma", 0, 24)); // NOI18N
cancelButt.setForeground(new java.awt.Color(255, 255, 255));
cancelButt.setText("Cancel");
cancelButt.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
cancelButt.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
cancelButtActionPerformed(evt);
}
});
getContentPane().add(cancelButt, new org.netbeans.lib.awtextra.AbsoluteConstraints(290, 330, 120, 70));
passwordGetText.setFont(new java.awt.Font("Tahoma", 1, 24)); // NOI18N
passwordGetText.setForeground(new java.awt.Color(204, 204, 204));
passwordGetText.setText("password");
passwordGetText.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
passwordGetTextMouseClicked(evt);
}
});
passwordGetText.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt) {
passwordGetTextKeyPressed(evt);
}
public void keyTyped(java.awt.event.KeyEvent evt) {
passwordGetTextKeyTyped(evt);
}
});
getContentPane().add(passwordGetText, new org.netbeans.lib.awtextra.AbsoluteConstraints(170, 260, 270, 40));
background.setIcon(new javax.swing.ImageIcon(getClass().getResource("/imageStart/Login.png"))); // NOI18N
background.setText("0357102284");
getContentPane().add(background, new org.netbeans.lib.awtextra.AbsoluteConstraints(0, 0, 500, -1));
pack();
}// </editor-fold>//GEN-END:initComponents
private void userTextMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_userTextMouseClicked
userText.setText("");
userText.setForeground(new java.awt.Color(0,0,0));
}//GEN-LAST:event_userTextMouseClicked
private void goRegisterMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_goRegisterMouseClicked
file.setUPM();
username = file.getUsername();
password = file.getPassword();
userMoney = file.getUserMoney();
RegisterForm regis = new RegisterForm();
regis.setVisible(true);
}//GEN-LAST:event_goRegisterMouseClicked
private void cancelButtActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cancelButtActionPerformed
userText.setForeground(new java.awt.Color(204, 204, 204));
userText.setText("username");
passwordGetText.setForeground(new java.awt.Color(204, 204, 204));
passwordGetText.setText("password");
}//GEN-LAST:event_cancelButtActionPerformed
private void loginButtActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_loginButtActionPerformed
runLogin();
}//GEN-LAST:event_loginButtActionPerformed
private void passwordGetTextMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_passwordGetTextMouseClicked
passwordGetText.setText("");
passwordGetText.setForeground(new java.awt.Color(0,0,0));
}//GEN-LAST:event_passwordGetTextMouseClicked
private void userTextKeyTyped(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_userTextKeyTyped
if(userText.getText().equals("username")){
userText.setText("");
userText.setForeground(new java.awt.Color(0,0,0));
}
}//GEN-LAST:event_userTextKeyTyped
private void passwordGetTextKeyTyped(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_passwordGetTextKeyTyped
if(passwordGetText.getText().equals("password")){
passwordGetText.setText("");
passwordGetText.setForeground(new java.awt.Color(0,0,0));
}
}//GEN-LAST:event_passwordGetTextKeyTyped
private void passwordGetTextKeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_passwordGetTextKeyPressed
if (evt.getKeyCode()==KeyEvent.VK_ENTER){
runLogin();
}
}//GEN-LAST:event_passwordGetTextKeyPressed
private void userTextKeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_userTextKeyPressed
if (evt.getKeyCode()==KeyEvent.VK_ENTER){
runLogin();
}
}//GEN-LAST:event_userTextKeyPressed
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(LoginForm.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(LoginForm.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(LoginForm.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(LoginForm.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new LoginForm().setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel background;
private javax.swing.JButton cancelButt;
private javax.swing.JTextField goRegister;
private javax.swing.JButton loginButt;
private javax.swing.JPasswordField passwordGetText;
private javax.swing.JTextField userText;
private javax.swing.JTextField wrong;
// End of variables declaration//GEN-END:variables
}
| [
"[email protected]"
] | |
13dd30a500c93fe58b58a588ac1a176dee047a84 | e315364f7c741e8536babdeb099372827cb7e1d4 | /src/main/java/com/vehicle/Exceptions/InvalidPayloadException.java | 166a372e1ded85e32ef85391c97e7755f2a7a68f | [] | no_license | zigatta1/MicroServicesTest1 | 54d7e9c6f24b223f7868add4714dacee5beb4e80 | bf89052dffc3980f2ca1482d0eace7048c29bf53 | refs/heads/master | 2021-03-28T00:01:11.947011 | 2020-03-16T21:26:44 | 2020-03-16T21:26:44 | 247,819,376 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 692 | java | package com.vehicle.Exceptions;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public class InvalidPayloadException extends RuntimeException {
private HttpStatus statusCode;
private String errorMessage;
public InvalidPayloadException(HttpStatus statusCode, String errorMessage) {
super(String.format("%s", errorMessage));
this.statusCode = statusCode;
this.errorMessage = errorMessage;
}
public HttpStatus getStatusCode() {
return statusCode;
}
public String getErrorMessage() {
return errorMessage;
}
}
| [
"[email protected]"
] | |
3c4c90a1e593ff6e1b1ae637c7302b079e71d1d8 | 74193a5db624f65340a28eb9450aff66094c2ea8 | /classKing/src/report/controller/AdminCommentReportDownServlet.java | 46e98e732d5e15bc31c43e637d04fb0ec52ca1cd | [] | no_license | mirew/classKing | c984da207fc9e25c146666097aaabc7c4d950a98 | 9f82ec4f472f2cb0d1c8ea30b5aabd61a1f892c4 | refs/heads/master | 2021-07-21T07:09:45.629374 | 2020-04-20T05:00:05 | 2020-04-20T05:00:05 | 139,300,417 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,075 | java | package report.controller;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class AdminCommentReportServlet
*/
@WebServlet("/rcdown")
public class AdminCommentReportDownServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public AdminCommentReportDownServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String readFolder = request.getSession().getServletContext().getRealPath("upload/comment_report_upload");
String originalFileName = request.getParameter("ofile");
String renameFileName = request.getParameter("rfile");
ServletOutputStream downOut = response.getOutputStream();
File downFile = new File(readFolder + "/" + renameFileName);
response.addHeader("Content-Disposition",
"attachment; filename=\"" + new String(originalFileName.getBytes("UTF-8"), "ISO-8859-1") + "\"");
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(downFile));
int read = -1;
while ((read = bin.read()) != -1) {
downOut.write(read);
downOut.flush();
}
downOut.close();
bin.close();
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
| [
"Mirew@Mirew-PC"
] | Mirew@Mirew-PC |
dd5929935af1470011715f1710b4dc54e71dee59 | 8f87065bc3cb6d96ea2e398a98aacda4fc4bbe43 | /src/Class00000052Better.java | af54ccffbe5a7e3e7577489b491ef23ca9570c86 | [] | no_license | fracz/code-quality-benchmark | a243d345441582473532f9b013993f77d59e19ae | c23e76fe315f43bea899beabb856e61348c34e09 | refs/heads/master | 2020-04-08T23:40:36.408828 | 2019-07-31T17:54:53 | 2019-07-31T17:54:53 | 159,835,188 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 411 | java | // original filename: 00040020.txt
// after
public class Class00000052Better {
@Override
public NodePropertyExistenceConstraint nodePropertyExistenceConstraintCreate(NodePropertyDescriptor descriptor) throws CreateConstraintFailureException, AlreadyConstrainedException {
statement.assertOpen();
return schemaWrite().nodePropertyExistenceConstraintCreate(statement, descriptor);
}
}
| [
"[email protected]"
] | |
c1978594ca758b1ae28ede18d6fb1e404fcf9863 | be1cd6a6d73fe1f099000091d5281ea0b6a1eab4 | /src/KnightAndDragon/action/Info.java | cd693647f6171d758986b0d11a824c3d701ada69 | [] | no_license | xym5202/DungeonsAndDragons | dcb449b147c52bac3f7f6d2e44f77296d999bffc | 65b706cf59c06930e96bd0fdaf29b930b80e1def | refs/heads/master | 2021-07-21T04:17:33.915708 | 2021-01-19T08:26:06 | 2021-01-19T08:26:06 | 235,071,567 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,319 | java | package KnightAndDragon.action;
import KnightAndDragon.Bean.Object.Knight;
import KnightAndDragon.util.TimeSleep;
public class Info {
static { info=new Info();
}
private static Info info;
private Info(){}
public static Info getInstance(){
return info;
}
//第一章背景信息
public void InfoOne(){
System.out.println("很久很久以前,有一座名叫奇亚洛的大陆，上面生活着各种各样的种群，有人类，精灵，矮人，瓦斯塔亚人等等，他们和谐的生活在一起");
TimeSleep.timeSleep(1000);
System.out.println("有一天，西方的一股强大的黑暗力量突然笼罩了这个世界，并向其他方向扩散开来，被黑暗感染的动物都会变的异常愤怒，盲目的攻击其他人");
TimeSleep.timeSleep(1000);
System.out.println("首先被黑暗吞噬的是西方的人类世界，大批幸存的居民们带上自己的行李，被迫踏上里离乡的旅程");
TimeSleep.timeSleep(1500);
System.out.println("在浩浩荡荡迁徙的人群中，有一名英雄和他的女儿走丢了，有人说看到他的女儿被一个穿着黑色斗篷的人带走了，沿着河岸向北方去了，而北边，正是矮人们的领地");
TimeSleep.timeSleep(1500);
System.out.println("于是，英雄扔掉了沉重的装备，加快速度，孤身一人前往北方，寻找自己的女儿");
TimeSleep.timeSleep(2000);
System.out.println("==================================\n第一章 哥布林之森");
TimeSleep.timeSleep(1500);
System.out.println("一直往北走，一大片森林矗立在眼前，这片森林生意盎然，确实哥布林的领地，虽然危险，但也是往北的必经之路，英雄咬了咬牙，走了进去。。。");
TimeSleep.timeSleep(3000);
}
//第二章背景信息
public void InfoTwo(){
Knight knight=Knight.getInstance();
System.out.println("离开格尔里斯，就进入到了矮人的领地");
System.out.println("金矿镇，离这里还有200里的路程，我的女儿已经被带走一周了，不知道还能不能赶得上");
System.out.println("想到这里，你皱了皱眉头，加快了脚步");
}
}
| [
"[email protected]"
] | |
fa823c940e9e611ff50122a96bf07d6d55d44ec7 | 129f58086770fc74c171e9c1edfd63b4257210f3 | /src/testcases/CWE760_Predictable_Salt_One_Way_Hash/CWE760_Predictable_Salt_One_Way_Hash__URLConnection_53d.java | 5d2d3e1f96f02514c41ec5d5cea5e2497ab24e59 | [] | no_license | glopezGitHub/Android23 | 1bd0b6a6c7ce3c7439a74f1e4dcef2c4c0fac4ba | 6215d0684c4fbdc7217ccfbedfccfca69824cc5e | refs/heads/master | 2023-03-07T15:14:59.447795 | 2023-02-06T13:59:49 | 2023-02-06T13:59:49 | 6,856,387 | 0 | 3 | null | 2023-02-06T18:38:17 | 2012-11-25T22:04:23 | Java | UTF-8 | Java | false | false | 2,277 | java | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE760_Predictable_Salt_One_Way_Hash__URLConnection_53d.java
Label Definition File: CWE760_Predictable_Salt_One_Way_Hash.label.xml
Template File: sources-sinks-53d.tmpl.java
*/
/*
* @description
* CWE: 760 Use of one-way hash with a predictable salt
* BadSource: URLConnection Read data from a web server with URLConnection
* GoodSource: A hardcoded string
* Sinks:
* GoodSink: use a sufficiently random salt
* BadSink : SHA512 with a predictable salt
* Flow Variant: 53 Data flow: data passed as an argument from one method through two others to a fourth; all four functions are in different classes in the same package
*
* */
package testcases.CWE760_Predictable_Salt_One_Way_Hash;
import testcasesupport.*;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import javax.servlet.http.*;
public class CWE760_Predictable_Salt_One_Way_Hash__URLConnection_53d
{
public void bad_sink(String data ) throws Throwable
{
if (data != null)
{
MessageDigest hash = MessageDigest.getInstance("SHA-512");
hash.update(data.getBytes("UTF-8")); /* POTENTIAL FLAW: SHA512 with a predictable salt */
byte[] hashv = hash.digest("hash me".getBytes("UTF-8"));
IO.writeLine(IO.toHex(hashv));
}
}
/* goodG2B() - use goodsource and badsink */
public void goodG2B_sink(String data ) throws Throwable
{
if (data != null)
{
MessageDigest hash = MessageDigest.getInstance("SHA-512");
hash.update(data.getBytes("UTF-8")); /* POTENTIAL FLAW: SHA512 with a predictable salt */
byte[] hashv = hash.digest("hash me".getBytes("UTF-8"));
IO.writeLine(IO.toHex(hashv));
}
}
/* goodB2G() - use badsource and goodsink */
public void goodB2G_sink(String data ) throws Throwable
{
SecureRandom r = new SecureRandom();
MessageDigest hash = MessageDigest.getInstance("SHA-512");
hash.update(r.getSeed(32)); /* FIX: Use a sufficiently random salt */
byte[] hashv = hash.digest("hash me".getBytes("UTF-8"));
IO.writeLine(IO.toHex(hashv));
}
}
| [
"[email protected]"
] | |
b651a98b9493a175c4e909e868b1a7fc1cc4e2ec | 569c7aafadc53464a957ba0d2e651c2d3f43489f | /Final/Matrices.java | d347c41b4662a412fdcb7f7a67eaeba48917e550 | [] | no_license | TheMiguelGt/JAVA | 678bc07549246ad48c976dad929d39b4450a8113 | 73ce76616705c11b7eb4cef92311925dfefeac1a | refs/heads/master | 2020-12-14T14:32:25.363242 | 2020-01-18T17:48:54 | 2020-01-18T17:48:54 | 234,769,410 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 26,352 | 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 Final;
import java.awt.Dimension;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import javax.swing.JOptionPane;
/**
*
* @author CAT
*/
public class Matrices extends javax.swing.JFrame {
public double funcion[][] = new double[4][3], det[] = new double[9], detx[] = new double[9], dety[] = new double[9], detz[] = new double[9];
public double re, errorelativo, errorelativo1, errorelativo2, deci, error, refun1, refun2, refun3, x, y, z;
public int i, j, conta = 1, ndecimales;
/**
* Creates new form Matrices
*/
public Matrices() {
initComponents();
this.setTitle("Metodo de Cramer");
this.setMaximumSize(new Dimension(461, 585));
this.setMinimumSize(new Dimension(461, 585));
jTcuadro.setEnabled(false);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jTres2 = new javax.swing.JTextField();
jLabel2 = new javax.swing.JLabel();
jTerror = new javax.swing.JTextField();
jLabel3 = new javax.swing.JLabel();
jTy2 = new javax.swing.JTextField();
jLabel4 = new javax.swing.JLabel();
jTz2 = new javax.swing.JTextField();
jLabel5 = new javax.swing.JLabel();
jTx = new javax.swing.JTextField();
jLabel6 = new javax.swing.JLabel();
jTy = new javax.swing.JTextField();
jLabel7 = new javax.swing.JLabel();
jTz = new javax.swing.JTextField();
jLabel8 = new javax.swing.JLabel();
jLabel9 = new javax.swing.JLabel();
jTres = new javax.swing.JTextField();
jTx1 = new javax.swing.JTextField();
jLabel10 = new javax.swing.JLabel();
jTy1 = new javax.swing.JTextField();
jLabel11 = new javax.swing.JLabel();
jTz1 = new javax.swing.JTextField();
jLabel12 = new javax.swing.JLabel();
jLabel13 = new javax.swing.JLabel();
jTres1 = new javax.swing.JTextField();
jLabel14 = new javax.swing.JLabel();
jLabel15 = new javax.swing.JLabel();
jLabel16 = new javax.swing.JLabel();
jTx2 = new javax.swing.JTextField();
jLabel17 = new javax.swing.JLabel();
jTndecimales = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jScrollPane2 = new javax.swing.JScrollPane();
jTcuadro = new javax.swing.JTextArea();
jLabel18 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jPanel1.setLayout(null);
jLabel1.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel1.setText("=");
jPanel1.add(jLabel1);
jLabel1.setBounds(300, 130, 20, 30);
jTres2.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTres2.setText("0");
jPanel1.add(jTres2);
jTres2.setBounds(310, 130, 60, 30);
jLabel2.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel2.setText("% error:");
jPanel1.add(jLabel2);
jLabel2.setBounds(370, 170, 100, 30);
jTerror.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTerror.setText("0");
jPanel1.add(jTerror);
jTerror.setBounds(270, 210, 140, 30);
jLabel3.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel3.setText("X");
jPanel1.add(jLabel3);
jLabel3.setBounds(120, 130, 10, 30);
jTy2.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTy2.setText("0");
jPanel1.add(jTy2);
jTy2.setBounds(140, 130, 60, 30);
jLabel4.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel4.setText("Y");
jPanel1.add(jLabel4);
jLabel4.setBounds(200, 130, 10, 30);
jTz2.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTz2.setText("0");
jPanel1.add(jTz2);
jTz2.setBounds(220, 130, 60, 30);
jLabel5.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel5.setText("Z");
jPanel1.add(jLabel5);
jLabel5.setBounds(280, 130, 20, 30);
jTx.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTx.setText("0");
jPanel1.add(jTx);
jTx.setBounds(60, 50, 60, 30);
jLabel6.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel6.setText("X");
jPanel1.add(jLabel6);
jLabel6.setBounds(120, 50, 10, 30);
jTy.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTy.setText("0");
jPanel1.add(jTy);
jTy.setBounds(140, 50, 60, 30);
jLabel7.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel7.setText("Y");
jPanel1.add(jLabel7);
jLabel7.setBounds(200, 50, 10, 30);
jTz.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTz.setText("0");
jTz.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTzActionPerformed(evt);
}
});
jPanel1.add(jTz);
jTz.setBounds(220, 50, 60, 30);
jLabel8.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel8.setText("Z");
jPanel1.add(jLabel8);
jLabel8.setBounds(280, 50, 20, 30);
jLabel9.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel9.setText("=");
jPanel1.add(jLabel9);
jLabel9.setBounds(300, 50, 20, 30);
jTres.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTres.setText("0");
jPanel1.add(jTres);
jTres.setBounds(310, 50, 60, 30);
jTx1.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTx1.setText("0");
jPanel1.add(jTx1);
jTx1.setBounds(60, 90, 60, 30);
jLabel10.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel10.setText("X");
jPanel1.add(jLabel10);
jLabel10.setBounds(120, 90, 10, 30);
jTy1.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTy1.setText("0");
jPanel1.add(jTy1);
jTy1.setBounds(140, 90, 60, 30);
jLabel11.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel11.setText("Y");
jPanel1.add(jLabel11);
jLabel11.setBounds(200, 90, 10, 30);
jTz1.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTz1.setText("0");
jPanel1.add(jTz1);
jTz1.setBounds(220, 90, 60, 30);
jLabel12.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel12.setText("Z");
jPanel1.add(jLabel12);
jLabel12.setBounds(280, 90, 20, 30);
jLabel13.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel13.setText("=");
jPanel1.add(jLabel13);
jLabel13.setBounds(300, 90, 20, 30);
jTres1.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTres1.setText("0");
jPanel1.add(jTres1);
jTres1.setBounds(310, 90, 60, 30);
jLabel14.setFont(new java.awt.Font("Dialog", 0, 120)); // NOI18N
jLabel14.setText("[");
jPanel1.add(jLabel14);
jLabel14.setBounds(20, 20, 40, 140);
jLabel15.setFont(new java.awt.Font("Dialog", 0, 120)); // NOI18N
jLabel15.setText("]");
jPanel1.add(jLabel15);
jLabel15.setBounds(380, 20, 40, 140);
jLabel16.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel16.setText("Funciones:");
jPanel1.add(jLabel16);
jLabel16.setBounds(10, 10, 80, 30);
jTx2.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTx2.setText("0");
jPanel1.add(jTx2);
jTx2.setBounds(60, 130, 60, 30);
jLabel17.setFont(new java.awt.Font("Dubai Light", 1, 15)); // NOI18N
jLabel17.setText("N° decimales:");
jPanel1.add(jLabel17);
jLabel17.setBounds(10, 170, 100, 30);
jTndecimales.setFont(new java.awt.Font("Dubai Light", 0, 14)); // NOI18N
jTndecimales.setText("0");
jPanel1.add(jTndecimales);
jTndecimales.setBounds(20, 210, 140, 30);
jButton1.setFont(new java.awt.Font("Dubai Light", 0, 15)); // NOI18N
jButton1.setText("Limpiar");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jPanel1.add(jButton1);
jButton1.setBounds(310, 500, 100, 30);
jButton2.setFont(new java.awt.Font("Dubai Light", 0, 15)); // NOI18N
jButton2.setText("Ejecutar");
jButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton2ActionPerformed(evt);
}
});
jPanel1.add(jButton2);
jButton2.setBounds(30, 500, 100, 30);
jTcuadro.setColumns(20);
jTcuadro.setFont(new java.awt.Font("Dubai Light", 1, 14)); // NOI18N
jTcuadro.setRows(5);
jScrollPane2.setViewportView(jTcuadro);
jPanel1.add(jScrollPane2);
jScrollPane2.setBounds(20, 270, 390, 210);
jLabel18.setIcon(new javax.swing.ImageIcon(getClass().getResource("/Final/weather-2400074_1280.jpg"))); // NOI18N
jLabel18.setText("jLabel18");
jPanel1.add(jLabel18);
jLabel18.setBounds(0, -10, 450, 570);
getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);
pack();
}// </editor-fold>//GEN-END:initComponents
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed
if (jTx.getText().trim().equals("")) {///////////////////////////////////////X///////////////////////////////
JOptionPane.showMessageDialog(null, "x de la primera funcion se encuentra vacia");
} else {
try {
funcion[0][0] = Double.parseDouble(jTx.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la x");
}
}
if (jTx1.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "x de la segunda funcion se encuentra vacia");
} else {
try {
funcion[0][1] = Double.parseDouble(jTx1.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la x");
}
}
if (jTx2.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "x de la tercera funcion se encuentra vacia");
} else {
try {
funcion[0][2] = Double.parseDouble(jTx2.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la x");
}
}
if (jTy.getText().trim().equals("")) {///////////////////////////////////////Y///////////////////////////////
JOptionPane.showMessageDialog(null, "y de la primera funcion se encuentra vacia");
} else {
try {
funcion[1][0] = Double.parseDouble(jTy.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la y");
}
}
if (jTy1.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "y de la segunda funcion se encuentra vacia");
} else {
try {
funcion[1][1] = Double.parseDouble(jTy1.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la y");
}
}
if (jTy2.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "y de la tercera funcion se encuentra vacia");
} else {
try {
funcion[1][2] = Double.parseDouble(jTy2.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la y");
}
}
if (jTz.getText().trim().equals("")) {///////////////////////////////////////Z///////////////////////////////
JOptionPane.showMessageDialog(null, "z de la primera funcion se encuentra vacia");
} else {
try {
funcion[2][0] = Double.parseDouble(jTz.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la z");
}
}
if (jTz1.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "z de la segunda funcion se encuentra vacia");
} else {
try {
funcion[2][1] = Double.parseDouble(jTz1.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la z");
}
}
if (jTz2.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "z de la tercera funcion se encuentra vacia");
} else {
try {
funcion[2][2] = Double.parseDouble(jTz2.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la z");
}
}
if (jTres.getText().trim().equals("")) {///////////////////////////////////////RES///////////////////////////////
JOptionPane.showMessageDialog(null, "resultado de la primera funcion se encuentra vacia");
} else {
try {
funcion[3][0] = Double.parseDouble(jTres.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en el resultado");
}
}
if (jTres1.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "resultado de la segunda funcion se encuentra vacia");
} else {
try {
funcion[3][1] = Double.parseDouble(jTres1.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en el resultado");
}
}
if (jTres2.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "resultado de la tercera funcion se encuentra vacia");
} else {
try {
funcion[3][2] = Double.parseDouble(jTres2.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en la resultado");
}
}
if (jTerror.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "Cuadro de texto del error se encuentra vacio");
} else {
try {
error = Double.parseDouble(jTerror.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en el error");
}
}
if (jTndecimales.getText().trim().equals("")) {
JOptionPane.showMessageDialog(null, "EL cuadro de texto de los decimales se encuentra vacio");
} else {
try {
ndecimales = Integer.parseInt(jTndecimales.getText());//string a double
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Ingrese solo numeros enteros en el numero de decimales");
}
}
det[0] = +(funcion[0][0] * funcion[1][1] * funcion[2][2]);/////////////////////determinante
det[1] = +(funcion[0][1] * funcion[1][2] * funcion[2][0]);
det[2] = +(funcion[0][2] * funcion[1][0] * funcion[2][1]);
det[3] = +det[0] + det[1] + det[2];
det[4] = -(funcion[2][0] * funcion[1][1] * funcion[0][2]);
det[5] = -(funcion[1][0] * funcion[0][1] * funcion[2][2]);
det[6] = -(funcion[2][1] * funcion[1][2] * funcion[0][0]);
det[7] = det[4] + det[5] + det[6];
det[8] = det[3] + det[7];
System.out.println("determinante " + det[8]);
detx[0] = +(funcion[3][0] * funcion[1][1] * funcion[2][2]);/////////////////////determinante x
detx[1] = +(funcion[3][1] * funcion[1][2] * funcion[2][0]);
detx[2] = +(funcion[3][2] * funcion[1][0] * funcion[2][1]);
detx[3] = detx[0] + detx[1] + detx[2];
detx[4] = -(funcion[2][0] * funcion[1][1] * funcion[3][2]);
detx[5] = -(funcion[1][0] * funcion[3][1] * funcion[2][2]);
detx[6] = -(funcion[2][1] * funcion[1][2] * funcion[3][0]);
detx[7] = detx[4] + detx[5] + detx[6];
detx[8] = (detx[3] + detx[7]) / det[8];
System.out.println("Determinante x " + detx[8]);
dety[0] = +(funcion[0][0] * funcion[3][1] * funcion[2][2]);/////////////////////determinante y
dety[1] = +(funcion[0][1] * funcion[3][2] * funcion[2][0]);
dety[2] = +(funcion[0][2] * funcion[3][0] * funcion[2][1]);
dety[3] = dety[0] + dety[1] + dety[2];
dety[4] = -(funcion[2][0] * funcion[3][1] * funcion[0][2]);
dety[5] = -(funcion[3][0] * funcion[0][1] * funcion[2][2]);
dety[6] = -(funcion[2][1] * funcion[3][2] * funcion[0][0]);
dety[7] = dety[4] + dety[5] + dety[6];
dety[8] = (dety[3] + dety[7]) / det[8];
System.out.println("Determinante y " + dety[8]);
detz[0] = +(funcion[0][0] * funcion[1][1] * funcion[3][2]);/////////////////////determinante y
detz[1] = +(funcion[0][1] * funcion[1][2] * funcion[3][0]);
detz[2] = +(funcion[0][2] * funcion[1][0] * funcion[3][1]);
detz[3] = detz[0] + detz[1] + detz[2];
detz[4] = -(funcion[3][0] * funcion[1][1] * funcion[0][2]);
detz[5] = -(funcion[1][0] * funcion[0][1] * funcion[3][2]);
detz[6] = -(funcion[3][1] * funcion[1][2] * funcion[0][0]);
detz[7] = detz[4] + detz[5] + detz[6];
detz[8] = (detz[3] + detz[7]) / det[8];
System.out.println("Determinante z " + detz[8]);
BigDecimal dete = new BigDecimal(det[8]);
dete = dete.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal detex = new BigDecimal(detx[8]);
detex = detex.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal detey = new BigDecimal(dety[8]);
detey = detey.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal detez = new BigDecimal(detz[8]);
detez = detez.setScale(ndecimales, RoundingMode.HALF_UP);
double deee = dete.doubleValue();
x = detex.doubleValue();
y = detey.doubleValue();
z = detez.doubleValue();
System.out.println(dete);
System.out.println(detex);
System.out.println(detey);
System.out.println(detez);
refun1 = (funcion[0][0] * x) + (funcion[1][0] * y) + (funcion[2][0] * z);
System.out.println("refun1 " + refun1);
refun2 = (funcion[0][1] * y) + (funcion[1][1] * y) + (funcion[2][1] * z);
System.out.println("refun2 " + refun2);
refun3 = (funcion[0][2] * x) + (funcion[1][2] * y) + (funcion[2][2] * z);
System.out.println("refun3 " + refun3);
errorelativo = Math.abs((funcion[3][0] - refun1) / funcion[3][0]) * 100;
System.out.println("error " + errorelativo);
errorelativo = Math.abs((funcion[3][1] - refun2) / funcion[3][1]) * 100;
System.out.println("error " + errorelativo1);
errorelativo = Math.abs((funcion[3][2] - refun3) / refun1) * 100;
System.out.println("error " + errorelativo2);
BigDecimal uno = new BigDecimal(errorelativo);
uno = uno.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal dos = new BigDecimal(errorelativo1);
dos = dos.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal tres = new BigDecimal(errorelativo2);
tres = tres.setScale(ndecimales, RoundingMode.HALF_UP);
BigDecimal res = new BigDecimal(re);
res = res.setScale(ndecimales, RoundingMode.HALF_UP);
double ress = res.doubleValue();
double po = uno.doubleValue();
double ka = dos.doubleValue();
double ca = tres.doubleValue();
System.out.println(ress);
ress = po + ka + ca / 3;
System.out.println("error " + po);
jTcuadro.append("Det " + deee
+ "\nX= " + x
+ "\nY= " + y
+ "\nZ= " + z
+ "\nEr1= " + po
+ "\nEr2= " + ka
+ "\nEr3= " + ca
+ "\nPm= " + res);
}//GEN-LAST:event_jButton2ActionPerformed
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
jTx.setText("0");
jTx1.setText("0");
jTx2.setText("0");
jTy.setText("0");
jTy1.setText("0");
jTy2.setText("0");
jTz.setText("0");
jTz1.setText("0");
jTz2.setText("0");
jTres.setText("0");
jTres1.setText("0");
jTres2.setText("0");
jTcuadro.setText("");
jTerror.setText("0");
jTndecimales.setText("0");
}//GEN-LAST:event_jButton1ActionPerformed
private void jTzActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jTzActionPerformed
// TODO add your handling code here:
}//GEN-LAST:event_jTzActionPerformed
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Matrices.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Matrices.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Matrices.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Matrices.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
Matrices mat = new Matrices();
mat.setVisible(true);
mat.setLocationRelativeTo(null);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel10;
private javax.swing.JLabel jLabel11;
private javax.swing.JLabel jLabel12;
private javax.swing.JLabel jLabel13;
private javax.swing.JLabel jLabel14;
private javax.swing.JLabel jLabel15;
private javax.swing.JLabel jLabel16;
private javax.swing.JLabel jLabel17;
private javax.swing.JLabel jLabel18;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel9;
private javax.swing.JPanel jPanel1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTextArea jTcuadro;
private javax.swing.JTextField jTerror;
private javax.swing.JTextField jTndecimales;
private javax.swing.JTextField jTres;
private javax.swing.JTextField jTres1;
private javax.swing.JTextField jTres2;
private javax.swing.JTextField jTx;
private javax.swing.JTextField jTx1;
private javax.swing.JTextField jTx2;
private javax.swing.JTextField jTy;
private javax.swing.JTextField jTy1;
private javax.swing.JTextField jTy2;
private javax.swing.JTextField jTz;
private javax.swing.JTextField jTz1;
private javax.swing.JTextField jTz2;
// End of variables declaration//GEN-END:variables
}
| [
"[email protected]"
] | |
363974e6c784778270308a6a7a029009daf01245 | a4948203b7d9beca56591971aa1b369cfc93233e | /src/main/java/it/dg/springexample/configuration/system/WebSystemConfig.java | 8b1fccd3315ecd41569b0d906b7077dcab6ec183 | [] | no_license | Gradom/spring-example | 36ffd5a35ba58f4032c0e9cec75cad37ea79bbce | 103fb9345128a2bfa8546f475388ff5f610c5aea | refs/heads/master | 2022-12-22T05:15:20.007908 | 2020-05-08T09:47:52 | 2020-05-08T09:47:52 | 236,781,007 | 0 | 0 | null | 2022-12-16T15:30:45 | 2020-01-28T16:26:27 | Java | UTF-8 | Java | false | false | 723 | java | package it.dg.springexample.configuration.system;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
/**
* @author Grasso Domenico
*
* Time: 12:38:43 Date: 24 apr 2020
*
* This config class is equivalent to servlet.xml file and is necessary
* to enable Spring. Whith it, the framework start the container and
* scan the base package to find all annotated class
* live @Controller, @Service, @RestController
*/
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "it.dg.springexample" })
public class WebSystemConfig {
}
| [
""
] | |
eb0b8f128652a157990b5b60bf8a99e01e5827e8 | 7b7fa1bb9614af14f8c993a9d7283b4d0c0d4d52 | /codechef/jd.java | 9752e9be72d67931d58c038364efb729238120a0 | [] | no_license | ThisIsRameshMishra/Programming-Questions | 8352a4395bf2850c7c3e347a5e1b0c4b20025217 | 93a043f746e7c2cf2198a6ff46babfde8c7e041e | refs/heads/master | 2023-06-10T01:01:33.030824 | 2021-07-04T14:41:57 | 2021-07-04T14:41:57 | 380,735,547 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 545 | java | package codechef;
import java.util.Scanner;
public class jd {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) {
int w1=sc.nextInt();
int w2=sc.nextInt();
int x1=sc.nextInt();
int x2=sc.nextInt();
int m=sc.nextInt();
int a=m*x1;
int b=m*x2;
int o=Math.max(a, b);
int p=Math.min(a, b);
int k=w2-w1;
if(k>=p && k<=o) {
System.out.println("1");
}
else {
System.out.println("0");
}
}
}
}
| [
"[email protected]"
] | |
8754441490301768c8a0dd33e6bff457a02537a0 | d9dfc034c961ab8fa77ded2aa389fb1ea57f1485 | /Projeto Automação Rest-Assured/src/test/java/br/com/ntconsult/teste/CenariosDeleteAPI.java | 3b08f6c38e9313601e13034ab1514e4ba09bb0de | [] | no_license | deivisonmartins/NTConsult | 38b30f912081c4a56ebe6c6d66f14783d307421b | 52f9fad13b7e040b2d44daf55ae4e15a2f3eeea0 | refs/heads/main | 2023-01-19T17:17:16.417503 | 2020-11-25T03:34:54 | 2020-11-25T03:34:54 | 312,701,145 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,036 | java | package br.com.ntconsult.teste;
import static io.restassured.RestAssured.given;
import org.junit.Test;
import br.com.ntconsult.teste.massa.Massa;
import io.restassured.response.Response;
public class CenariosDeleteAPI extends Massa{
@Test
public void deletePost1(){
Response response =
given().
contentType("application/json").
when().
delete(api + "posts/" + id1);
response.then().statusCode(200);
}
@Test
public void deletePost2(){
Response response =
given().
contentType("application/json").
when().
delete(api + "posts/" + id2);
response.then().statusCode(200);
}
@Test
public void deletePost3(){
Response response =
given().
contentType("application/json").
when().
delete(api + "posts/" + id3);
response.then().statusCode(200);
}
@Test
public void deletePost4(){
Response response =
given().
contentType("application/json").
when().
delete(api + "posts/" + id4);
response.then().statusCode(200);
}
} | [
"[email protected]"
] | |
939873edd14d2240625acc48f87726ec28301706 | 43e94df6fe0439e74a5a66d21ba70f14e2008de6 | /app/src/main/java/com/ussd/mysoft/uz/RusUcell_internetpaket.java | 84a5e4d254d2abcdc468dab7b83d7eb0036fc2cb | [] | no_license | Maqsadjon/UssdUzbekistanApk | c4af958b2002e40bfd147587d31cb53c6beab769 | 5becaf743e11b9a8c8807b8b5f926ad779b691f8 | refs/heads/master | 2023-07-14T14:40:47.528294 | 2021-08-24T13:29:45 | 2021-08-24T13:29:45 | 399,472,788 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,278 | java | package com.ussd.mysoft.uz;
import android.Manifest;
import android.annotation.SuppressLint;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.cardview.widget.CardView;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
public class RusUcell_internetpaket extends AppCompatActivity implements View.OnClickListener {
private CardView ucell_1gb;
private CardView ucell_1500;
private CardView ucell_2gb;
private CardView ucell_4gb;
private CardView ucell_7gb;
private CardView ucell_10gb;
private CardView ucell_13gb;
private CardView ucell_20gb;
private CardView ucell_30gb;
private CardView ucell_50gb;
private CardView ucell_80gb;
private CardView ucell_90gb;
private CardView ucell_135gb;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rus_ucell_internetpaket);
Toolbar toolbar = findViewById(R.id.toolbar_topbeel);
ImageView arrow = toolbar.findViewById(R.id.backbeel);
arrow.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
finish();
}
});
setSupportActionBar(toolbar);
setTitle("");
initObjects();
getWindow().setStatusBarColor(Color.parseColor("#AC89FB"));
}
@SuppressLint("WrongViewCast")
private void initObjects(){
ucell_1gb=findViewById(R.id.ucell_1gb);
ucell_1gb.setOnClickListener(this);
ucell_1500=findViewById(R.id.ucell_1500);
ucell_1500.setOnClickListener(this);
ucell_2gb=findViewById(R.id.ucell_2gb);
ucell_2gb.setOnClickListener(this);
ucell_4gb=findViewById(R.id.ucell_4gb);
ucell_4gb.setOnClickListener(this);
ucell_7gb=findViewById(R.id.ucell_7gb);
ucell_7gb.setOnClickListener(this);
ucell_10gb=findViewById(R.id.ucell_10gb);
ucell_10gb.setOnClickListener(this);
ucell_13gb=findViewById(R.id.ucell_13gb);
ucell_13gb.setOnClickListener(this);
ucell_20gb=findViewById(R.id.ucell_20gb);
ucell_20gb.setOnClickListener(this);
ucell_30gb=findViewById(R.id.ucell_30gb);
ucell_30gb.setOnClickListener(this);
ucell_50gb=findViewById(R.id.ucell_50gb);
ucell_50gb.setOnClickListener(this);
ucell_80gb=findViewById(R.id.ucell_80gb);
ucell_80gb.setOnClickListener(this);
ucell_90gb=findViewById(R.id.ucell_90gb);
ucell_90gb.setOnClickListener(this);
ucell_135gb=findViewById(R.id.ucell_135gb);
ucell_135gb.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.ucell_1gb:
String cUssducellint1 = "558*555*3*1*22523";
String cToSenducellint1= "tel:*" + cUssducellint1 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint1)));
}
break;
case R.id.ucell_1500:
String cUssducellint2 = "558*555*3*2*22523";
String cToSenducellint2= "tel:*" + cUssducellint2 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint2)));
}
break;
case R.id.ucell_2gb:
String cUssducellint3 = "558*555*3*3*22523";
String cToSenducellint3= "tel:*" + cUssducellint3 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint3)));
}
break;
case R.id.ucell_4gb:
String cUssducellint4 = "558*555*3*4*22523";
String cToSenducellint4= "tel:*" + cUssducellint4 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint4)));
}
break;
case R.id.ucell_7gb:
String cUssducellint5 = "558*555*3*5*22523";
String cToSenducellint5= "tel:*" + cUssducellint5 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint5)));
}
break;
case R.id.ucell_10gb:
String cUssducellint6 = "558*555*3*13*22523";
String cToSenducellint6= "tel:*" + cUssducellint6 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint6)));
}
break;
case R.id.ucell_13gb:
String cUssducellint7 = "558*555*3*6*22523";
String cToSenducellint7= "tel:*" + cUssducellint7 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint7)));
}
break;
case R.id.ucell_20gb:
String cUssducellint8 = "558*555*3*7*22523";
String cToSenducellint8= "tel:*" + cUssducellint8 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint8)));
}
break;
case R.id.ucell_30gb:
String cUssducellint9 = "558*555*3*8*22523";
String cToSenducellint9= "tel:*" + cUssducellint9 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint9)));
}
break;
case R.id.ucell_50gb:
String cUssducellint10 = "558*555*3*9*22523";
String cToSenducellint10= "tel:*" + cUssducellint10 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint10)));
}
break;
case R.id.ucell_80gb:
String cUssducellint11 = "558*555*3*10*22523";
String cToSenducellint11= "tel:*" + cUssducellint11 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint11)));
}
break;
case R.id.ucell_90gb:
String cUssducellint12 = "558*555*3*11*22523";
String cToSenducellint12= "tel:*" + cUssducellint12 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint12)));
}
break;
case R.id.ucell_135gb:
String cUssducellint13 = "558*555*3*12*22523";
String cToSenducellint13= "tel:*" + cUssducellint13 + Uri.encode("#");
if (ContextCompat.checkSelfPermission(RusUcell_internetpaket.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(RusUcell_internetpaket.this, new String[]{Manifest.permission.CALL_PHONE},100);
}
else
{
startActivity(new Intent("android.intent.action.CALL",
Uri.parse(cToSenducellint13)));
}
break;
}
}
} | [
"[email protected]"
] | |
a27910fbf0822a9d848f9d9ee5dafdc41a601117 | c476f882b1b8760590a41c3037493cb9da06677d | /src/algo/heap/Heap.java | 23d4f905f0c293bb1a62a76d8475cd213f5e63b7 | [] | no_license | Aayers-ghw/data_structure_algorithms | 8d63cef8f951e90734cf48f8ef55f4d05fc81afb | 1bd0e12db80b709ca90fe472f70df31bce54333e | refs/heads/master | 2022-03-02T04:43:20.389619 | 2019-09-27T13:12:16 | 2019-09-27T13:12:16 | 198,058,088 | 1 | 0 | null | null | null | null | GB18030 | Java | false | false | 2,450 | java | package algo.heap;
import java.util.Arrays;
/**
* @author Aayers-ghw
*/
public class Heap {
/**
* 数组，从下标1开始存储数据
*/
private int[] a;
/**
* 堆可以存储的最大数据个数
*/
private int n;
/**
* 堆中已经存储的数据个数
*/
private int count;
public Heap(int capacity) {
a = new int[capacity];
n = capacity;
count = 0;
}
/**
* 往堆中插入数据，从下往上
*
* @param data
*/
public void insert(int data) {
if (count == n) {
return; //堆满了
}
++count;
a[count] = data;
int i = count;
//自下往上堆化
while (i / 2 >= 1 && a[i] > a[i / 2]) {
//交换下标为i和i/2的两个元素
swap(a, i, i / 2);
i = i / 2;
}
}
/**
* 删除堆顶元素
*/
public void removeMax() {
if (count == 0) {
//堆中没有数据
return;
}
a[1] = a[count];
count--;
heapify(a, n, 1);
}
public static void heapify(int[] a, int n, int i) { //自上往下堆化
while (true) {
int maxPos = i;
if (i * 2 <= n && a[i] < a[i * 2]) {
maxPos = i * 2;
}
if (i * 2 + 1 <= n && a[maxPos] < a[i * 2 + 1]) {
maxPos = i * 2 + 1;
}
if (maxPos == i) {
break;
}
swap(a, i, maxPos);
i = maxPos;
}
}
public static void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
/**
* 堆排序
* 1.建堆
* 2.排序
*/
public static void buildHeap(int[] a, int n) {
for (int i = n / 2; i >= 1; --i) {
heapify(a, n, i);
}
}
/**
* n表示数据的个数，数组a中的数据从下标1到n的位置
*
* @param a
* @param n
*/
public static void sort(int[] a, int n) {
buildHeap(a, n);
int k = n;
while (k > 1) {
swap(a, 1, k);
k--;
heapify(a, k, 1);
}
}
public static void main(String[] args) {
int[] a = {0, 5, 4, 3, 2, 1};
sort(a, 5);
System.out.println(Arrays.toString(a));
}
}
| [
"[email protected]"
] | |
f816e637288e4e87d962a9ad5d751b508edd4e32 | c885ef92397be9d54b87741f01557f61d3f794f3 | /results/Csv-8/org.apache.commons.csv.CSVFormat/BBC-F0-opt-10/tests/8/org/apache/commons/csv/CSVFormat_ESTest.java | 1a5379b4a6fa422e8c2253cc86d88db973a081c3 | [
"CC-BY-4.0",
"MIT"
] | permissive | pderakhshanfar/EMSE-BBC-experiment | f60ac5f7664dd9a85f755a00a57ec12c7551e8c6 | fea1a92c2e7ba7080b8529e2052259c9b697bbda | refs/heads/main | 2022-11-25T00:39:58.983828 | 2022-04-12T16:04:26 | 2022-04-12T16:04:26 | 309,335,889 | 0 | 1 | null | 2021-11-05T11:18:43 | 2020-11-02T10:30:38 | null | UTF-8 | Java | false | false | 84,206 | java | /*
* This file was automatically generated by EvoSuite
* Thu Oct 14 00:44:30 GMT 2021
*/
package org.apache.commons.csv;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.runtime.EvoAssertions.*;
import java.io.Reader;
import java.io.StringReader;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.Quote;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true)
public class CSVFormat_ESTest extends CSVFormat_ESTest_scaffolding {
@Test(timeout = 4000)
public void test000() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
assertFalse(cSVFormat1.isCommentingEnabled());
cSVFormat1.validate();
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('*', (char)cSVFormat1.getEscape());
assertTrue(cSVFormat1.isEscaping());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test001() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withDelimiter('@');
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertFalse(cSVFormat1.equals((Object)cSVFormat0));
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('@', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(boolean0);
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test002() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
cSVFormat0.validate();
assertEquals("\n", cSVFormat0.getRecordSeparator());
}
@Test(timeout = 4000)
public void test003() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("sF#)~");
CSVFormat cSVFormat2 = cSVFormat1.withSkipHeaderRecord(true);
assertEquals("sF#)~", cSVFormat2.getNullString());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test004() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('~');
CSVFormat cSVFormat2 = cSVFormat1.withSkipHeaderRecord(false);
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.isCommentingEnabled());
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertEquals('w', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.isEscaping());
assertEquals('~', (char)cSVFormat2.getCommentStart());
assertFalse(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test005() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator("RecordSeparator=<");
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.isQuoting());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isEscaping());
}
@Test(timeout = 4000)
public void test006() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("_*>kzS)K");
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator(';');
assertFalse(cSVFormat2.isCommentingEnabled());
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isQuoting());
assertEquals('\t', cSVFormat1.getDelimiter());
assertEquals("_*>kzS)K", cSVFormat2.getNullString());
assertEquals(";", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat1.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test007() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withRecordSeparator(';');
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(";", cSVFormat1.getRecordSeparator());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test008() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('D');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('Q');
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator('Q');
assertEquals('D', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertEquals("Q", cSVFormat2.getRecordSeparator());
assertEquals('Q', (char)cSVFormat2.getCommentStart());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat2.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test009() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('D');
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator('Q');
assertFalse(cSVFormat2.isNullHandling());
assertEquals("Q", cSVFormat2.getRecordSeparator());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertEquals('D', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test010() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('D');
CSVFormat cSVFormat1 = cSVFormat0.withIgnoreSurroundingSpaces(true);
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator('Q');
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals("Q", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertEquals('D', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test011() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("string");
Quote quote0 = Quote.NON_NUMERIC;
CSVFormat cSVFormat2 = cSVFormat1.withQuotePolicy(quote0);
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isEscaping());
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals("string", cSVFormat2.getNullString());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test012() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('f');
Quote quote0 = Quote.NON_NUMERIC;
CSVFormat cSVFormat2 = cSVFormat1.withQuotePolicy(quote0);
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('f', (char)cSVFormat2.getCommentStart());
assertTrue(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test013() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
Quote quote0 = Quote.NONE;
CSVFormat cSVFormat2 = cSVFormat1.withQuotePolicy(quote0);
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isQuoting());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.isNullHandling());
}
@Test(timeout = 4000)
public void test014() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('}');
CSVFormat cSVFormat1 = cSVFormat0.withNullString("");
Character character0 = new Character('A');
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar(character0);
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isNullHandling());
assertEquals('}', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertTrue(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test015() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Character character0 = Character.valueOf('');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar(character0);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\\', (char)cSVFormat2.getEscape());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('', (char)cSVFormat2.getCommentStart());
}
@Test(timeout = 4000)
public void test016() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar((Character) null);
assertFalse(cSVFormat2.isQuoting());
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertTrue(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test017() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
Character character0 = new Character('L');
CSVFormat cSVFormat1 = cSVFormat0.TDF.withQuoteChar(character0);
assertFalse(cSVFormat1.isEscaping());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test018() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("Index for header '%s' is %d but CSVRecord only has %d values!");
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar('~');
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('~', (char)cSVFormat2.getQuoteChar());
assertEquals("Index for header '%s' is %d but CSVRecord only has %d values!", cSVFormat2.getNullString());
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test019() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('Q');
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar('Q');
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('Q', (char)cSVFormat2.getQuoteChar());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.isCommentingEnabled());
assertEquals('Q', (char)cSVFormat1.getEscape());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test020() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withQuoteChar('\\');
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('\\', (char)cSVFormat2.getQuoteChar());
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat2.isQuoting());
assertEquals(',', cSVFormat1.getDelimiter());
}
@Test(timeout = 4000)
public void test021() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withQuoteChar('A');
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('A', (char)cSVFormat1.getQuoteChar());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test022() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Character character0 = Character.valueOf('');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
CSVFormat cSVFormat2 = cSVFormat1.withNullString("_*>kzS)K");
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('', (char)cSVFormat2.getCommentStart());
assertEquals("_*>kzS)K", cSVFormat2.getNullString());
assertTrue(cSVFormat2.isEscaping());
assertEquals("\n", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('\\', (char)cSVFormat2.getEscape());
}
@Test(timeout = 4000)
public void test023() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withNullString("e&VyG\"v2[7l)!<WYRpS");
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isEscaping());
assertEquals("e&VyG\"v2[7l)!<WYRpS", cSVFormat2.getNullString());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test024() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('}');
CSVFormat cSVFormat1 = cSVFormat0.withNullString("");
CSVFormat cSVFormat2 = cSVFormat1.withIgnoreSurroundingSpaces(true);
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertEquals('}', cSVFormat2.getDelimiter());
assertTrue(cSVFormat2.isNullHandling());
}
@Test(timeout = 4000)
public void test025() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('@');
CSVFormat cSVFormat2 = cSVFormat1.withIgnoreSurroundingSpaces(false);
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertEquals('@', (char)cSVFormat2.getCommentStart());
assertTrue(cSVFormat2.getIgnoreEmptyLines());
assertTrue(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
}
@Test(timeout = 4000)
public void test026() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withIgnoreSurroundingSpaces(false);
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.getSkipHeaderRecord());
assertTrue(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
}
@Test(timeout = 4000)
public void test027() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withIgnoreSurroundingSpaces(true);
Quote quote0 = Quote.NON_NUMERIC;
CSVFormat cSVFormat2 = cSVFormat1.withQuotePolicy(quote0);
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isNullHandling());
}
@Test(timeout = 4000)
public void test028() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString(";iq?{Y?~z");
CSVFormat cSVFormat2 = cSVFormat1.withDelimiter('#');
CSVFormat cSVFormat3 = cSVFormat2.withIgnoreEmptyLines(true);
assertTrue(cSVFormat3.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat3.equals((Object)cSVFormat2));
assertEquals("\r\n", cSVFormat3.getRecordSeparator());
assertTrue(cSVFormat3.getIgnoreEmptyLines());
assertTrue(cSVFormat3.isQuoting());
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertEquals(";iq?{Y?~z", cSVFormat3.getNullString());
assertEquals('#', cSVFormat3.getDelimiter());
assertFalse(cSVFormat3.isEscaping());
}
@Test(timeout = 4000)
public void test029() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.MYSQL.withIgnoreEmptyLines(true);
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test030() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('D');
CSVFormat cSVFormat1 = cSVFormat0.withIgnoreEmptyLines(false);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.equals((Object)cSVFormat0));
assertEquals('D', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test031() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString(";iq?{Y?~z");
String[] stringArray0 = new String[4];
CSVFormat cSVFormat2 = cSVFormat1.withHeader(stringArray0);
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(";iq?{Y?~z", cSVFormat2.getNullString());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('\t', cSVFormat1.getDelimiter());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertTrue(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test032() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('R');
CSVFormat cSVFormat2 = cSVFormat1.withHeader((String[]) null);
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isEscaping());
assertEquals('R', (char)cSVFormat2.getCommentStart());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.isNullHandling());
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertTrue(cSVFormat2.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test033() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withHeader((String[]) null);
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isEscaping());
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertTrue(cSVFormat2.getIgnoreEmptyLines());
assertTrue(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test034() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("CsNnE0&blCFw");
Character character0 = new Character('E');
CSVFormat cSVFormat2 = cSVFormat1.withEscape(character0);
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isCommentingEnabled());
assertEquals("CsNnE0&blCFw", cSVFormat2.getNullString());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test035() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withEscape((Character) null);
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('\t', cSVFormat1.getDelimiter());
}
@Test(timeout = 4000)
public void test036() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = Character.valueOf(',');
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withEscape(character0);
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test037() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
Character character0 = Character.valueOf('Y');
CSVFormat cSVFormat1 = cSVFormat0.withEscape(character0);
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat1.isQuoting());
assertEquals('Y', (char)cSVFormat1.getEscape());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test038() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("string");
CSVFormat cSVFormat2 = cSVFormat1.withEscape('f');
assertEquals("string", cSVFormat2.getNullString());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isCommentingEnabled());
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('f', (char)cSVFormat2.getEscape());
assertTrue(cSVFormat1.isQuoting());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test039() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withEscape('N');
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat2.isCommentingEnabled());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isNullHandling());
assertEquals('N', (char)cSVFormat2.getEscape());
assertTrue(cSVFormat2.isEscaping());
}
@Test(timeout = 4000)
public void test040() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withDelimiter('N');
assertEquals('N', cSVFormat2.getDelimiter());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat2.isNullHandling());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.isEscaping());
}
@Test(timeout = 4000)
public void test041() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withNullString(") invalid parse sequence");
Character character0 = Character.valueOf('T');
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart(character0);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals("\r\n", cSVFormat2.getRecordSeparator());
assertTrue(cSVFormat2.isCommentingEnabled());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals(") invalid parse sequence", cSVFormat2.getNullString());
}
@Test(timeout = 4000)
public void test042() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.MYSQL.withSkipHeaderRecord(true);
Character character0 = cSVFormat1.getQuoteChar();
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart(character0);
assertTrue(cSVFormat2.equals((Object)cSVFormat1));
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test043() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Character character0 = Character.valueOf('K');
CSVFormat cSVFormat1 = cSVFormat0.TDF.withEscape('K');
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart(character0);
assertEquals('\t', cSVFormat1.getDelimiter());
assertEquals('K', (char)cSVFormat2.getEscape());
assertFalse(cSVFormat2.isNullHandling());
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertTrue(cSVFormat1.isEscaping());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test044() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("string");
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart('f');
CSVFormat cSVFormat3 = cSVFormat2.withDelimiter('f');
assertTrue(cSVFormat3.isCommentingEnabled());
assertFalse(cSVFormat3.getSkipHeaderRecord());
assertEquals("\r\n", cSVFormat3.getRecordSeparator());
assertEquals('f', cSVFormat3.getDelimiter());
assertFalse(cSVFormat3.getIgnoreSurroundingSpaces());
assertEquals('f', (char)cSVFormat3.getCommentStart());
assertTrue(cSVFormat1.isQuoting());
assertEquals("string", cSVFormat3.getNullString());
assertFalse(cSVFormat3.isEscaping());
assertFalse(cSVFormat3.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test045() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart('&');
assertFalse(cSVFormat2.isNullHandling());
assertEquals('*', (char)cSVFormat2.getEscape());
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('&', (char)cSVFormat2.getCommentStart());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
}
@Test(timeout = 4000)
public void test046() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('D');
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart('Q');
CSVFormat cSVFormat3 = cSVFormat2.withIgnoreEmptyLines(true);
assertTrue(cSVFormat3.isCommentingEnabled());
assertFalse(cSVFormat3.isQuoting());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat3.isEscaping());
assertEquals('D', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertEquals('Q', (char)cSVFormat3.getCommentStart());
assertFalse(cSVFormat3.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertFalse(cSVFormat3.equals((Object)cSVFormat2));
}
@Test(timeout = 4000)
public void test047() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('f');
CSVFormat cSVFormat2 = cSVFormat1.withDelimiter('f');
CSVFormat cSVFormat3 = cSVFormat2.withEscape('f');
assertEquals('\"', (char)cSVFormat3.getQuoteChar());
assertFalse(cSVFormat3.isNullHandling());
assertEquals('f', cSVFormat2.getDelimiter());
assertEquals('f', (char)cSVFormat3.getEscape());
assertEquals('f', (char)cSVFormat3.getCommentStart());
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat3.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat3.getIgnoreEmptyLines());
assertFalse(cSVFormat3.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test048() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
boolean boolean0 = cSVFormat1.getSkipHeaderRecord();
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertTrue(boolean0);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test049() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withRecordSeparator((String) null);
CSVFormat cSVFormat2 = cSVFormat1.withEscape('\\');
cSVFormat2.getRecordSeparator();
assertTrue(cSVFormat2.isEscaping());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('\\', (char)cSVFormat2.getEscape());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(',', cSVFormat1.getDelimiter());
}
@Test(timeout = 4000)
public void test050() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withRecordSeparator("");
String string0 = cSVFormat1.getRecordSeparator();
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\t', cSVFormat1.getDelimiter());
assertNotNull(string0);
}
@Test(timeout = 4000)
public void test051() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Quote quote0 = Quote.NON_NUMERIC;
CSVFormat cSVFormat1 = cSVFormat0.withQuotePolicy(quote0);
cSVFormat1.getQuotePolicy();
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test052() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
Character character0 = Character.valueOf('4');
CSVFormat cSVFormat1 = cSVFormat0.withQuoteChar(character0);
Character character1 = cSVFormat1.getQuoteChar();
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertNotNull(character1);
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test053() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('}');
CSVFormat cSVFormat1 = cSVFormat0.withQuoteChar('d');
Character character0 = cSVFormat1.getQuoteChar();
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertEquals('d', (char)character0);
assertNotNull(character0);
assertEquals('}', cSVFormat0.getDelimiter());
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test054() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("7tUib,1q");
String string0 = cSVFormat1.getNullString();
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals("7tUib,1q", string0);
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test055() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("");
String string0 = cSVFormat1.getNullString();
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertFalse(cSVFormat1.isEscaping());
assertTrue(cSVFormat1.isQuoting());
assertEquals('\t', cSVFormat1.getDelimiter());
assertEquals("", string0);
}
@Test(timeout = 4000)
public void test056() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
boolean boolean0 = cSVFormat0.getIgnoreSurroundingSpaces();
assertTrue(boolean0);
}
@Test(timeout = 4000)
public void test057() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
boolean boolean0 = cSVFormat0.getIgnoreEmptyLines();
assertTrue(boolean0);
}
@Test(timeout = 4000)
public void test058() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
String[] stringArray0 = new String[4];
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
cSVFormat1.getHeader();
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test059() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
Character character0 = cSVFormat1.getEscape();
assertTrue(cSVFormat1.isQuoting());
assertEquals('*', (char)character0);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isCommentingEnabled());
assertNotNull(character0);
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test060() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('0');
Character character0 = cSVFormat1.getEscape();
assertFalse(cSVFormat1.isNullHandling());
assertEquals('0', (char)character0);
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertNotNull(character0);
}
@Test(timeout = 4000)
public void test061() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = Character.valueOf('Z');
CSVFormat cSVFormat1 = cSVFormat0.withEscape(character0);
Character character1 = cSVFormat1.getEscape();
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertEquals('Z', (char)character1);
assertNotNull(character1);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test062() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withDelimiter('8');
char char0 = cSVFormat1.getDelimiter();
assertEquals('8', char0);
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test063() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
char char0 = cSVFormat0.getDelimiter();
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertEquals('w', char0);
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test064() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Character character0 = Character.valueOf('');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
Character character1 = cSVFormat1.getCommentStart();
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals('', (char)character1);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertEquals('\\', (char)cSVFormat1.getEscape());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test065() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
Character character0 = Character.valueOf('2');
CSVFormat cSVFormat1 = cSVFormat0.EXCEL.withCommentStart(character0);
Character character1 = cSVFormat1.getCommentStart();
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertNotNull(character1);
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test066() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = Character.valueOf('x');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
Character character1 = cSVFormat1.getCommentStart();
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertNotNull(character1);
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test067() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Object[] objectArray0 = new Object[0];
String string0 = cSVFormat0.TDF.format(objectArray0);
assertEquals("", string0);
}
@Test(timeout = 4000)
public void test068() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
// Undeclared exception!
try {
cSVFormat0.withQuoteChar('\n');
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The quoteChar cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test069() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
// Undeclared exception!
try {
cSVFormat0.withEscape('\n');
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The escape character cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test070() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withDelimiter('@');
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart('@');
StringReader stringReader0 = new StringReader("NON_NUMERIC");
// Undeclared exception!
try {
cSVFormat2.parse(stringReader0);
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The comment start character and the delimiter cannot be the same ('@')
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test071() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
// Undeclared exception!
try {
cSVFormat0.parse((Reader) null);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Parameter 'reader' must not be null!
//
verifyException("org.apache.commons.csv.Assertions", e);
}
}
@Test(timeout = 4000)
public void test072() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
Character character0 = new Character('\r');
// Undeclared exception!
try {
cSVFormat0.EXCEL.withCommentStart(character0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The comment start character cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test073() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
boolean boolean0 = cSVFormat0.isQuoting();
assertTrue(boolean0);
}
@Test(timeout = 4000)
public void test074() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
boolean boolean0 = cSVFormat0.isQuoting();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test075() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
boolean boolean0 = cSVFormat0.isNullHandling();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test076() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
boolean boolean0 = cSVFormat0.isEscaping();
assertTrue(boolean0);
}
@Test(timeout = 4000)
public void test077() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
boolean boolean0 = cSVFormat0.isEscaping();
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
assertFalse(boolean0);
assertEquals('w', cSVFormat0.getDelimiter());
assertFalse(cSVFormat0.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test078() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
boolean boolean0 = cSVFormat0.isCommentingEnabled();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test079() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
Character character0 = Character.valueOf('T');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
boolean boolean0 = cSVFormat1.isCommentingEnabled();
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertTrue(boolean0);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test080() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
String[] stringArray0 = cSVFormat0.getHeader();
assertNull(stringArray0);
}
@Test(timeout = 4000)
public void test081() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
String[] stringArray0 = new String[0];
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
cSVFormat1.getHeader();
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test082() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
boolean boolean0 = cSVFormat0.getIgnoreSurroundingSpaces();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test083() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
cSVFormat0.getQuotePolicy();
}
@Test(timeout = 4000)
public void test084() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
Character character0 = cSVFormat0.getQuoteChar();
assertEquals('\"', (char)character0);
}
@Test(timeout = 4000)
public void test085() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
String string0 = cSVFormat0.getNullString();
assertNull(string0);
}
@Test(timeout = 4000)
public void test086() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = cSVFormat0.getCommentStart();
assertNull(character0);
}
@Test(timeout = 4000)
public void test087() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
boolean boolean0 = cSVFormat0.getIgnoreEmptyLines();
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertEquals('w', cSVFormat0.getDelimiter());
assertFalse(boolean0);
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test088() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
String string0 = cSVFormat0.getRecordSeparator();
assertEquals("\r\n", string0);
}
@Test(timeout = 4000)
public void test089() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
cSVFormat0.getEscape();
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertEquals('w', cSVFormat0.getDelimiter());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test090() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('}');
char char0 = cSVFormat0.getDelimiter();
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertEquals('}', char0);
assertFalse(cSVFormat0.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test091() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = new Character('\r');
// Undeclared exception!
try {
cSVFormat0.withQuoteChar(character0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The quoteChar cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test092() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
// Undeclared exception!
try {
cSVFormat0.withCommentStart('\r');
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The comment start character cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test093() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
String[] stringArray0 = new String[2];
stringArray0[0] = "";
stringArray0[1] = "";
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
try {
cSVFormat1.validate();
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The header contains duplicate names: [, ]
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test094() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Quote quote0 = Quote.NONE;
CSVFormat cSVFormat1 = cSVFormat0.EXCEL.withQuotePolicy(quote0);
Object[] objectArray0 = new Object[1];
// Undeclared exception!
try {
cSVFormat1.format(objectArray0);
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// No quotes mode set but no escape character is set
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test095() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = Character.valueOf('x');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
CSVFormat cSVFormat2 = cSVFormat1.withEscape(character0);
try {
cSVFormat2.validate();
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The comment start and the escape character cannot be the same ('x')
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test096() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
Character character0 = new Character('~');
CSVFormat cSVFormat1 = cSVFormat0.withQuoteChar(character0);
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart(character0);
Object[] objectArray0 = new Object[7];
// Undeclared exception!
try {
cSVFormat2.format(objectArray0);
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The comment start character and the quoteChar cannot be the same ('~')
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test097() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = new Character('(');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
// Undeclared exception!
try {
cSVFormat1.format((Object[]) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
verifyException("org.apache.commons.csv.CSVPrinter", e);
}
}
@Test(timeout = 4000)
public void test098() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
CSVFormat cSVFormat2 = cSVFormat1.withDelimiter('*');
try {
cSVFormat2.validate();
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The escape character and the delimiter cannot be the same ('*')
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test099() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
Character character0 = new Character(',');
CSVFormat cSVFormat1 = cSVFormat0.withQuoteChar(character0);
try {
cSVFormat1.validate();
fail("Expecting exception: IllegalStateException");
} catch(IllegalStateException e) {
//
// The quoteChar character and the delimiter cannot be the same (',')
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test100() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
String[] stringArray0 = new String[6];
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
String string0 = cSVFormat1.toString();
assertEquals("Delimiter=<\t> QuoteChar=<\"> RecordSeparator=<\r\n> EmptyLines:ignored SurroundingSpaces:ignored SkipHeaderRecord:false Header:[null, null, null, null, null, null]", string0);
}
@Test(timeout = 4000)
public void test101() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
String string0 = cSVFormat0.toString();
assertEquals("Delimiter=<w> SkipHeaderRecord:false", string0);
}
@Test(timeout = 4000)
public void test102() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("e&VyG\"v2[7l)!<WYRpS");
String string0 = cSVFormat1.toString();
assertEquals("Delimiter=<,> QuoteChar=<\"> NullString=<e&VyG\"v2[7l)!<WYRpS> RecordSeparator=<\r\n> SkipHeaderRecord:false", string0);
}
@Test(timeout = 4000)
public void test103() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("");
boolean boolean0 = cSVFormat1.isNullHandling();
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertTrue(boolean0);
assertEquals("", cSVFormat1.getNullString());
}
@Test(timeout = 4000)
public void test104() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(';');
String string0 = cSVFormat1.toString();
assertEquals("Delimiter=<\t> QuoteChar=<\"> CommentStart=<;> RecordSeparator=<\r\n> EmptyLines:ignored SurroundingSpaces:ignored SkipHeaderRecord:false", string0);
}
@Test(timeout = 4000)
public void test105() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withRecordSeparator((String) null);
cSVFormat1.hashCode();
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('\t', cSVFormat1.getDelimiter());
}
@Test(timeout = 4000)
public void test106() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString(";iq?{Y?~z");
cSVFormat1.hashCode();
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertEquals(";iq?{Y?~z", cSVFormat1.getNullString());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
assertEquals('\t', cSVFormat1.getDelimiter());
}
@Test(timeout = 4000)
public void test107() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('>');
cSVFormat1.hashCode();
assertEquals('>', (char)cSVFormat1.getCommentStart());
assertTrue(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test108() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
cSVFormat0.MYSQL.hashCode();
}
@Test(timeout = 4000)
public void test109() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('}');
Quote quote0 = Quote.ALL;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withQuotePolicy(quote0);
cSVFormat1.hashCode();
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat0.getSkipHeaderRecord());
}
@Test(timeout = 4000)
public void test110() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
String[] stringArray0 = new String[0];
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
assertFalse(cSVFormat1.isCommentingEnabled());
StringReader stringReader0 = new StringReader("\n");
CSVParser cSVParser0 = cSVFormat1.parse(stringReader0);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals(1L, cSVParser0.getRecordNumber());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test111() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
Character character0 = new Character('*');
CSVFormat cSVFormat2 = cSVFormat0.withEscape(character0);
boolean boolean0 = cSVFormat1.equals(cSVFormat2);
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertTrue(boolean0);
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertTrue(cSVFormat2.isQuoting());
assertEquals(',', cSVFormat2.getDelimiter());
assertFalse(cSVFormat2.equals((Object)cSVFormat0));
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertEquals('*', (char)cSVFormat2.getEscape());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test112() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withRecordSeparator((String) null);
CSVFormat cSVFormat2 = cSVFormat1.withNullString((String) null);
boolean boolean0 = cSVFormat1.equals(cSVFormat2);
assertFalse(cSVFormat2.equals((Object)cSVFormat0));
assertTrue(boolean0);
assertTrue(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat2.isQuoting());
}
@Test(timeout = 4000)
public void test113() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(boolean0);
assertFalse(cSVFormat1.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test114() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withSkipHeaderRecord(false);
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(boolean0);
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test115() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withIgnoreSurroundingSpaces(false);
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat1.isQuoting());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(boolean0);
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test116() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withNullString(";iq?{Y?~z");
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator((String) null);
boolean boolean0 = cSVFormat2.equals(cSVFormat1);
assertFalse(cSVFormat2.isEscaping());
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat2.isQuoting());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(boolean0);
assertTrue(cSVFormat2.isNullHandling());
}
@Test(timeout = 4000)
public void test117() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("OR*D4*[~v");
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(boolean0);
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertEquals("OR*D4*[~v", cSVFormat1.getNullString());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
}
@Test(timeout = 4000)
public void test118() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('*');
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertEquals('*', (char)cSVFormat1.getEscape());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test119() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('-');
CSVFormat cSVFormat2 = cSVFormat0.withRecordSeparator("_Qb7:A?gE-rTq[wqbY]");
boolean boolean0 = cSVFormat2.equals(cSVFormat1);
assertFalse(cSVFormat2.getSkipHeaderRecord());
assertFalse(cSVFormat0.equals((Object)cSVFormat1));
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat2.getIgnoreEmptyLines());
assertFalse(cSVFormat2.getIgnoreSurroundingSpaces());
assertEquals('-', (char)cSVFormat1.getEscape());
assertTrue(cSVFormat2.isQuoting());
assertFalse(cSVFormat2.isNullHandling());
assertEquals(',', cSVFormat2.getDelimiter());
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test120() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('`');
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(boolean0);
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals('`', (char)cSVFormat1.getCommentStart());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
}
@Test(timeout = 4000)
public void test121() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
Character character0 = Character.valueOf('');
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart(character0);
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals('\\', (char)cSVFormat1.getEscape());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(boolean0);
assertFalse(cSVFormat1.isQuoting());
assertEquals('', (char)cSVFormat1.getCommentStart());
}
@Test(timeout = 4000)
public void test122() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('>');
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator("The comment start and the escape character cannot be the same ('");
boolean boolean0 = cSVFormat2.equals(cSVFormat1);
assertEquals('\"', (char)cSVFormat2.getQuoteChar());
assertEquals('>', (char)cSVFormat2.getCommentStart());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.equals((Object)cSVFormat0));
assertEquals('\t', cSVFormat1.getDelimiter());
assertTrue(cSVFormat2.isQuoting());
assertFalse(boolean0);
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat2.isNullHandling());
}
@Test(timeout = 4000)
public void test123() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.TDF.withEscape('K');
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(boolean0);
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertEquals('K', (char)cSVFormat1.getEscape());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test124() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.TDF.withEscape('K');
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertTrue(cSVFormat1.isQuoting());
assertEquals('K', (char)cSVFormat1.getEscape());
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(boolean0);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('\"', (char)cSVFormat1.getQuoteChar());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isEscaping());
assertTrue(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
}
@Test(timeout = 4000)
public void test125() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.newFormat('w');
Quote quote0 = Quote.MINIMAL;
CSVFormat cSVFormat1 = cSVFormat0.withQuotePolicy(quote0);
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertFalse(cSVFormat0.getIgnoreEmptyLines());
assertFalse(cSVFormat0.getSkipHeaderRecord());
assertFalse(boolean0);
assertFalse(cSVFormat0.getIgnoreSurroundingSpaces());
assertEquals('w', cSVFormat0.getDelimiter());
}
@Test(timeout = 4000)
public void test126() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withDelimiter('@');
CSVFormat cSVFormat2 = cSVFormat1.withCommentStart('@');
boolean boolean0 = cSVFormat2.equals(cSVFormat0);
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat0.equals((Object)cSVFormat1));
assertFalse(cSVFormat2.isEscaping());
assertFalse(cSVFormat2.isNullHandling());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertEquals('@', (char)cSVFormat2.getCommentStart());
assertEquals('@', cSVFormat1.getDelimiter());
assertTrue(cSVFormat2.isCommentingEnabled());
assertFalse(cSVFormat1.equals((Object)cSVFormat0));
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test127() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
Object object0 = new Object();
boolean boolean0 = cSVFormat0.equals(object0);
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test128() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
boolean boolean0 = cSVFormat0.equals((Object) null);
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test129() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
boolean boolean0 = cSVFormat0.equals(cSVFormat0);
assertTrue(boolean0);
}
@Test(timeout = 4000)
public void test130() throws Throwable {
// Undeclared exception!
try {
CSVFormat.newFormat('\n');
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The delimiter cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test131() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
Character character0 = new Character('\r');
// Undeclared exception!
try {
cSVFormat0.withEscape(character0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The escape character cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test132() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
// Undeclared exception!
try {
cSVFormat0.withDelimiter('\n');
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The delimiter cannot be a line break
//
verifyException("org.apache.commons.csv.CSVFormat", e);
}
}
@Test(timeout = 4000)
public void test133() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.DEFAULT.withRecordSeparator('`');
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isQuoting());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertEquals(',', cSVFormat1.getDelimiter());
assertEquals("`", cSVFormat1.getRecordSeparator());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test134() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.RFC4180;
String[] stringArray0 = new String[3];
CSVFormat cSVFormat1 = cSVFormat0.withHeader(stringArray0);
boolean boolean0 = cSVFormat0.equals(cSVFormat1);
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isNullHandling());
assertTrue(cSVFormat1.isQuoting());
assertEquals(',', cSVFormat1.getDelimiter());
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test135() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
CSVFormat cSVFormat1 = cSVFormat0.withEscape('W');
assertEquals('\t', cSVFormat1.getDelimiter());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.isCommentingEnabled());
assertTrue(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertEquals('W', (char)cSVFormat1.getEscape());
}
@Test(timeout = 4000)
public void test136() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withCommentStart('h');
CSVFormat cSVFormat2 = cSVFormat1.withRecordSeparator((String) null);
CSVFormat cSVFormat3 = cSVFormat2.withQuoteChar('~');
assertFalse(cSVFormat2.equals((Object)cSVFormat1));
assertFalse(cSVFormat1.isNullHandling());
assertFalse(cSVFormat3.getIgnoreSurroundingSpaces());
assertTrue(cSVFormat3.isCommentingEnabled());
assertEquals('~', (char)cSVFormat3.getQuoteChar());
assertFalse(cSVFormat3.isEscaping());
assertEquals(',', cSVFormat3.getDelimiter());
assertTrue(cSVFormat3.getIgnoreEmptyLines());
assertEquals('h', (char)cSVFormat3.getCommentStart());
assertFalse(cSVFormat3.getSkipHeaderRecord());
assertTrue(cSVFormat3.isQuoting());
}
@Test(timeout = 4000)
public void test137() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.DEFAULT;
CSVFormat cSVFormat1 = cSVFormat0.withNullString("Index for header '%s' is %d but CSVRecord only has %d values!");
boolean boolean0 = cSVFormat1.equals(cSVFormat0);
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.getIgnoreEmptyLines());
assertFalse(cSVFormat1.getSkipHeaderRecord());
assertTrue(cSVFormat1.isQuoting());
assertFalse(boolean0);
assertEquals("\r\n", cSVFormat1.getRecordSeparator());
assertEquals("Index for header '%s' is %d but CSVRecord only has %d values!", cSVFormat1.getNullString());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.isEscaping());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
}
@Test(timeout = 4000)
public void test138() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
StringReader stringReader0 = new StringReader("D^zI");
CSVParser cSVParser0 = cSVFormat0.parse(stringReader0);
assertEquals(0L, cSVParser0.getRecordNumber());
}
@Test(timeout = 4000)
public void test139() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
String string0 = cSVFormat0.MYSQL.toString();
assertEquals("Delimiter=<\t> Escape=<\\> RecordSeparator=<\n> SkipHeaderRecord:false", string0);
}
@Test(timeout = 4000)
public void test140() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.EXCEL;
CSVFormat cSVFormat1 = cSVFormat0.withSkipHeaderRecord(true);
cSVFormat1.hashCode();
assertFalse(cSVFormat1.getIgnoreEmptyLines());
assertTrue(cSVFormat1.getSkipHeaderRecord());
assertFalse(cSVFormat1.getIgnoreSurroundingSpaces());
assertFalse(cSVFormat1.isCommentingEnabled());
assertFalse(cSVFormat1.isNullHandling());
assertEquals(',', cSVFormat1.getDelimiter());
assertTrue(cSVFormat1.isQuoting());
assertFalse(cSVFormat1.isEscaping());
}
@Test(timeout = 4000)
public void test141() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.MYSQL;
boolean boolean0 = cSVFormat0.getSkipHeaderRecord();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test142() throws Throwable {
CSVFormat cSVFormat0 = CSVFormat.TDF;
String[] stringArray0 = new String[4];
String string0 = cSVFormat0.format(stringArray0);
assertEquals("\"\"", string0);
}
}
| [
"[email protected]"
] | |
720da999e27086cbc3613f55b15ce3f9ab3c7d0f | 74817982bc8aa8399da3d506cb31050f5c5f7f58 | /src/main/java/de/balogha/footballint/dbrestservice/rest/hateoas/PlayerResourceAssembler.java | e1a6b4652768316f2393fd6aa56aac20428ee5ce | [] | no_license | AlexanderB-demo/football-db-webservice | d1e631373f7ada37d217589f664180128f7cfb14 | bd077b3e8f69f244b72642a3e774ae7e6fc1e09e | refs/heads/master | 2020-11-29T15:25:25.525390 | 2017-04-06T23:12:30 | 2017-04-06T23:12:30 | 87,480,649 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,192 | java | package de.balogha.footballint.dbrestservice.rest.hateoas;
import de.balogha.footballint.dbrestservice.model.Player;
import de.balogha.footballint.dbrestservice.rest.controller.PlayerController;
import org.springframework.hateoas.Resource;
import org.springframework.hateoas.mvc.ResourceAssemblerSupport;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
@Component
public class PlayerResourceAssembler extends ResourceAssemblerSupport<Player, Resource> {
public PlayerResourceAssembler() {
super(PlayerController.class, Resource.class);
}
@Override
public List<Resource> toResources(Iterable<? extends Player> entities) {
List<Resource> resources = new ArrayList<>();
entities.forEach(player -> resources.add(toResource(player)));
return resources;
}
@Override
public Resource<Player> toResource(Player entity) {
return new Resource<>(entity, linkTo(PlayerController.class)
.slash(entity.getId())
.withSelfRel());
}
}
| [
"[email protected]"
] | |
bd0e32fe7efad18333a4a6fbdb625cc76e942f14 | 4f0e33a5dab58c3b553c0189f03823f32068e13f | /modules/client/src/test/java/com/mindbox/pe/client/pear/ResearchLabelFont.java | 1a9b1c7681faf6dfc5dc3844a2860f897ccc82bd | [] | no_license | josfernandez-clgx/PowerEditor | 6e2e1f098fa11c871e6a0b8da982cca2ab22e285 | a4399706feb4dfb2d10c8209ead59d6639e98473 | refs/heads/master | 2023-06-08T01:48:26.053551 | 2020-06-02T22:15:00 | 2020-06-02T22:15:00 | 379,699,653 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,460 | java | package com.mindbox.pe.client.pear;
import java.awt.Container;
import java.awt.Font;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class ResearchLabelFont {
private static void createAndShowGUI() {
JFrame mainFrame = new JFrame();
Container mainPane = mainFrame.getContentPane();
mainPane.setLayout(new BoxLayout(mainPane, BoxLayout.Y_AXIS));
JPanel mainPanel = new JPanel();
mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.X_AXIS));
JLabel labelA = new JLabel("LabelA", JLabel.CENTER);
Font labelFont = labelA.getFont();
String fontName = labelFont.getName();
int fontSize = labelFont.getSize();
Font newLabelFont = new Font(fontName, Font.BOLD, fontSize * 2);
labelA.setFont(newLabelFont);
mainPanel.add(Box.createHorizontalGlue());
mainPanel.add(labelA);
mainPanel.add(Box.createHorizontalGlue());
mainPane.add(mainPanel);
mainFrame.pack();
mainFrame.setVisible(true);
}
public static void main(String args[]) {
System.out.println("Hello, world\n");
javax.swing.SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
createAndShowGUI();
}
});
}
}
| [
"josfernandez@84317e12-416e-11ea-976c-191aa12963f2"
] | josfernandez@84317e12-416e-11ea-976c-191aa12963f2 |
5a2b1f42c36a8d6d9b293ff7b01bd81dad4aa1ed | 182fa296149fc591687e8a7234a355ec5594ef06 | /room-web-app/src/main/java/com/springboot/bootingweb/roomwebapp/data/RoomRepository.java | 14af797238929b3882607148db421137bd5cffb0 | [] | no_license | MoAmr/booting-spring | aa04e7c125cdd7f3eb39418d192d25dd558d0128 | 59043c8181ae54f231c2aec871eac4771f1dd57c | refs/heads/main | 2023-05-12T21:48:21.930830 | 2021-06-01T08:09:37 | 2021-06-01T08:09:37 | 372,295,901 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 329 | java | package com.springboot.bootingweb.roomwebapp.data;
import com.springboot.bootingweb.roomwebapp.models.Room;
import org.springframework.data.jpa.repository.JpaRepository;
/**
* @author Mohammed Amr
* @created 31/05/2021 - 04:16
* @project booting-web
*/
public interface RoomRepository extends JpaRepository<Room, Long> {
}
| [
"[email protected]"
] | |
4451e7c5f069c515711711960e6066c12fdc25da | 47abfdb4b7b0d398b61a61ee8a0b0ed2c5ff5a74 | /PAOC/src/paoc/editparts/FeatureTreeEditPart.java | 035cf387cc1c48ebc3b2fe0c50b1c2584496ce4f | [] | no_license | helunwencser/PAOC | 533702e123071dfeb3c83a0583ac97246f76be8c | 797ccd4f820f61ef2a01330b403ce9e35c9b5895 | refs/heads/master | 2016-08-05T13:06:04.475027 | 2014-12-24T06:36:35 | 2014-12-24T06:36:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,592 | java | package paoc.editparts;
import java.beans.PropertyChangeEvent;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.gef.EditPolicy;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import paoc.model.ControlConnection;
import paoc.model.Feature;
import paoc.model.SenseConnection;
import paoc.policies.DeleteComponentEditPolicy;
public class FeatureTreeEditPart extends TreeEditPart {
protected void refreshVisuals(){
Feature model = (Feature) this.getModel();
this.setWidgetText(model.getFeatureName());
this.setWidgetImage(PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT));
}
public void propertyChange(PropertyChangeEvent event){
if(event.getPropertyName().equals(Feature.P_TEXT))
refreshVisuals();
else if(event.getPropertyName().equals(Feature.P_CHILDREN))
{
refreshChildren();
this.getRoot().getContents().refresh();
}
}
protected void createEditPolicies(){
this.installEditPolicy(EditPolicy.COMPONENT_ROLE, new DeleteComponentEditPolicy());
}
protected List<Object> getModelChildren(){
List<Object> children = new ArrayList<Object>();
List<?> targetConnections = ((Feature)this.getModel()).getTargetConnections();
for(int i = 0; i < targetConnections.size(); i++){
Object connection = targetConnections.get(i);
if(connection instanceof SenseConnection)
children.add(((SenseConnection) connection).getSource());
else if(connection instanceof ControlConnection)
children.add(((ControlConnection) connection).getSource());
}
return children;
}
}
| [
"[email protected]"
] | |
4c067cedc38c6bb729fd7ee1817368c30ac965c5 | 1268044139a39cd32f2a5eb49bc6428bcbaed11b | /pharmacy-web/src/main/java/com/pharmacy/controller/pricecheck/PriceCheckController.java | 3ccb91223376dad9b63870f55592647d1f36f142 | [] | no_license | Pikolu/Pharmacy-Spring-MVC-Hibernate | b724600e241154bf193ec91d6ee2e89115fb65ab | 5a5e43e1ba540d4537047b15c482fcded8c3f22a | refs/heads/master | 2016-09-06T14:17:52.568736 | 2015-10-06T19:09:41 | 2015-10-06T19:09:41 | 34,687,831 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,290 | java | /*
* Copyright 2015 Alexandr.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.pharmacy.controller.pricecheck;
import com.pharmacy.article.Article;
import com.pharmacy.controller.abstraction.AbstractController;
import com.pharmacy.service.api.ArticleService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
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;
/**
*
* @author Alexandr
*/
@Controller
public class PriceCheckController extends AbstractController {
@Autowired
private ArticleService articleService;
@RequestMapping(value = "/preisvergleich/{articelNumber}/{name}", method = RequestMethod.GET)
public ModelAndView loadAllPharmacyForPriceCheck(@PathVariable String articelNumber, @PathVariable String name, @RequestParam(required = false) String page, HttpServletRequest request, HttpSession session) {
ModelAndView modelAndView = new ModelAndView("priceCheck");
Article article = articleService.findArticleByArticelNumber(articelNumber);
int currentpage;
if (page == null) {
currentpage = 1;
} else {
currentpage = Integer.valueOf(page);
}
getFilterOptions().setCurrentPage(currentpage);
setPage(page, modelAndView, (long)article.getPrices().size());
modelAndView.addObject("article", article);
return modelAndView;
}
}
| [
"[email protected]"
] | |
a74d20b49b7b10a4a30ecddd24df01ab315b1891 | 4024269f63da318a2e9de78d6bbb501eaa466c7f | /src/main/java/com/wavemaker/notification/service/impl/ActivityServiceImpl.java | e8e3f998f8cd0ff44b0cb87d08a9488c0ddd8868 | [] | no_license | Tarun-Dubey/NotificationSystem | 992ed50476fd01b66afafcb8e1c9a72953e8f262 | 938cfbd7dba26fa4cdecbcb88e812a19cbf7de2d | refs/heads/master | 2021-01-19T02:59:47.002457 | 2016-08-04T05:41:28 | 2016-08-04T05:41:28 | 64,905,227 | 2 | 1 | null | null | null | null | UTF-8 | Java | false | false | 866 | java | package com.wavemaker.notification.service.impl;
import com.wavemaker.notification.entity.Activity;
import com.wavemaker.notification.entity.ActivityStub;
import com.wavemaker.notification.manager.ActivityManager;
import com.wavemaker.notification.service.ActivityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
/**
* Created by tarund on 26/7/16.
*/
@Service
public class ActivityServiceImpl implements ActivityService {
@Autowired
ActivityManager activityManager;
public void createActivity(ActivityStub activityStub){
activityManager.createActivity(activityStub);
}
public List<Activity> listActivities(Map<String, List<String>> providers) {
return activityManager.listActivities(providers);
}
}
| [
"[email protected]"
] | |
f54a04a383c11660d1fc2cd08a5432ec599d58b9 | d00431df301064385c4e774c8d1908e2eaca67fd | /src/main/java/com/jiyao/customize/service/impl/SubscribeEventImpl.java | 3bc45026daa0df6d59b12c0d15e3a08ae975729d | [] | no_license | JiYao-tech/customize | b9383867935c37820c6e6397d7b4831585511be2 | b206727c2ac81c3445cab5d9f75a4522ecc9e588 | refs/heads/master | 2023-03-05T14:19:12.850872 | 2021-02-19T06:55:58 | 2021-02-19T06:55:58 | 328,613,992 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,041 | java | package com.jiyao.customize.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.jiyao.customize.common.request.HikCommonRequest;
import com.jiyao.customize.service.SubscribeEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
/**
* @author 36536
*/
@Service
public class SubscribeEventImpl implements SubscribeEvent {
@Value("${server.ip}")
private String localhostIp;
@Value("${server.port}")
private String localhostPort;
@Autowired
private HikCommonRequest hikCommonRequest;
@Override
@PostConstruct
public void subscribeAccessEvent() {
int[] eventCode = new int[]{983299,983300,983301,983307,983308,983309,983310};
//STEP4：请求路径
String path = "/api/eventService/v1/eventSubscriptionByEventTypes";
/**
* STEP5：组装请求参数
*/
JSONObject jsonBody = new JSONObject();
jsonBody.put("eventTypes", eventCode);
jsonBody.put("eventDest", "http://"+localhostIp+":"+localhostPort+"/v1/personAccess");
String result = hikCommonRequest.requestRusult(path, jsonBody.toJSONString(), "application/json");
//解析返回值
JSONObject jsonObject = JSONObject.parseObject(result);
if(jsonObject.getString("code").equals("0")){
System.out.println("订阅事件成功："+result);
queryEventSubscriptionView();
}else {
System.out.println("订阅事件失败："+result);
}
}
@Override
public void queryEventSubscriptionView() {
//STEP4：请求路径
String path = "/api/eventService/v1/eventSubscriptionView";
/**
* STEP6：调用接口
*/
String result = hikCommonRequest.requestRusult(path, null, "application/json");
System.out.println("已订阅成功："+result);
}
}
| [
"[email protected]"
] | |
be1c9a109ae8ec1305ef5c0488876f8bd4e8adda | 280d31084c976a61e8e3e731959f2da1c1b019c7 | /src/main/java/com/akshay/dao/OrderDAO.java | f791d884979127b3917327188b228c362a0e0415 | [] | no_license | AkshayaPk/res-core | 774b0f934ad89f2bdc010fb752916b38fcc223e3 | 394fffb20ac12adba181cd91e4fee98db9ba0687 | refs/heads/master | 2021-04-30T17:05:34.592300 | 2017-02-01T10:44:19 | 2017-02-01T10:44:19 | 80,182,911 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 4,095 | java | package com.akshay.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlOutParameter;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import com.akshay.model.Order;
import com.akshay.model.Seat;
import com.akshay.util.ConnectionUtil;
public class OrderDAO {
private static final String ERRMSG2 = "errmsg";
private static final String I_ORDERID = "i_orderid";
private final JdbcTemplate jdbcTemplate = ConnectionUtil.getJdbcTemplate();
/**
* TO INSERT A RECORD INTO THE ORDER RELATION.
*
* @param order
*/
public void save(final Order order) {
final String sql = "insert into order_transaction(ORDER_NO,ORDER_DATE,ORDER_TIME,ORDER_SEAT_NO)"
+ "values (?,?,?,?)";
final Object[] params = { order.getOrderNo(), order.getOrderDate(), order.getOrderTime(),
order.getOrderSeatNo().getSeatNo() };
jdbcTemplate.update(sql, params);
}
/**
* TO DELETE A RECORD FROM THE ORDER RELATION.
*
* @param order
*/
public void delete(final int orderNo) {
final String sql = "delete from order_transaction where ORDER_NO=?";
jdbcTemplate.update(sql, orderNo);
}
/**
* TO VIEW ALL RECORDS FROM THE ORDER RELATION.
*
* @param order
*/
public List<Order> list() {
final String sql = "select ORDER_NO,ORDER_DATE,ORDER_TIME,ORDER_SEAT_NO from order_transaction";
return jdbcTemplate.query(sql, (rs, rowNum) ->
convert(rs)
);
}
static Order convert(final ResultSet rs) throws SQLException {
final Order order = new Order();
order.setOrderNo(rs.getInt("ORDER_NO"));
order.setOrderDate(rs.getDate("ORDER_DATE").toLocalDate());
order.setOrderTime(rs.getTime("ORDER_TIME").toLocalTime());
final Seat seat = new Seat();
seat.setSeatNo(rs.getInt("ORDER_SEAT_NO"));
order.setOrderSeatNo(seat);
return order;
}
public String placeOrder(String foodname, String quantity, int orderid, int seatno, String errmsg) {
SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate).withProcedureName("PR_ORDERFOOD").declareParameters(
new SqlParameter("_food", Types.VARCHAR), new SqlParameter("_quan", Types.VARCHAR),
new SqlParameter(I_ORDERID, Types.INTEGER), new SqlParameter("i_seatno", Types.INTEGER),
new SqlOutParameter(ERRMSG2, Types.VARCHAR));
call.setAccessCallParameterMetaData(false);
SqlParameterSource in = new MapSqlParameterSource().addValue("_food", foodname).addValue("_quan", quantity)
.addValue(I_ORDERID, orderid).addValue("i_seatno", seatno).addValue(ERRMSG2, errmsg);
Map<String, Object> execute = call.execute(in);
return (String) execute.get(ERRMSG2);
}
public String cancelOrder(int orderid, String foodname, String errmsg) {
SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate).withProcedureName("PR_CANCEL_ORDER").declareParameters(
new SqlParameter(I_ORDERID, Types.INTEGER), new SqlParameter("i_foodname", Types.VARCHAR),
new SqlOutParameter(ERRMSG2, Types.VARCHAR));
call.setAccessCallParameterMetaData(false);
SqlParameterSource in = new MapSqlParameterSource().addValue(I_ORDERID, orderid)
.addValue("i_foodname", foodname).addValue(ERRMSG2, errmsg);
return (String) call.execute(in).get(ERRMSG2);
}
public Boolean validateOrderNo(int orderNo) {
String sql = "select FN_CHECK_ORDERNO(?)";
return jdbcTemplate.queryForObject(sql, new Object[] { orderNo }, Boolean.class);
}
public Boolean checkItemCategoryServed(String foodname) {
String sql = "select FN_IS_ITEM_CATEGORY_SERVED(?)";
return jdbcTemplate.queryForObject(sql, new Object[] { foodname }, Boolean.class);
}
public Boolean checkNumberOfItemsOrdered(String foodname) {
String sql = "select FN_CHECK_NUMBER_ITEMS(?)";
return jdbcTemplate.queryForObject(sql, new Object[] { foodname }, Boolean.class);
}
}
| [
"akshay pk"
] | akshay pk |
aab9dd8a57cce904e2bfaf9354243f2b6d4ebc32 | 8b5d6c8965011d818399df2de6292a377962672d | /src/secp256k1/src/java/org/catra/NativeSecp256k1Util.java | a165578a62a09c53558880c649ef81d00ad5e696 | [
"MIT",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | catracoin/catracoin | 56e921b6bb27f04de0d847c57c9bb7b64d2ecfbd | 0ecd8ec316e2bdb180325e26ff6bcb857ceea6c9 | refs/heads/master | 2023-02-19T14:34:38.056169 | 2021-01-20T15:07:39 | 2021-01-20T15:07:39 | 331,340,760 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,541 | java | /*
* Copyright 2014-2016 the libsecp256k1 contributors
*
* 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.catra;
public class NativeSecp256k1Util{
public static void assertEquals( int val, int val2, String message ) throws AssertFailException{
if( val != val2 )
throw new AssertFailException("FAIL: " + message);
}
public static void assertEquals( boolean val, boolean val2, String message ) throws AssertFailException{
if( val != val2 )
throw new AssertFailException("FAIL: " + message);
else
System.out.println("PASS: " + message);
}
public static void assertEquals( String val, String val2, String message ) throws AssertFailException{
if( !val.equals(val2) )
throw new AssertFailException("FAIL: " + message);
else
System.out.println("PASS: " + message);
}
public static class AssertFailException extends Exception {
public AssertFailException(String message) {
super( message );
}
}
}
| [
"[email protected]"
] | |
1766087220d44af2e9838e564759032689a9347b | 2fd9d77d529e9b90fd077d0aa5ed2889525129e3 | /DecompiledViberSrc/app/src/main/java/com/viber/jni/ViberInInfo.java | bf8b6eacb05004cfdfd348c8c656c3669b8c66dc | [] | no_license | cga2351/code | 703f5d49dc3be45eafc4521e931f8d9d270e8a92 | 4e35fb567d359c252c2feca1e21b3a2a386f2bdb | refs/heads/master | 2021-07-08T15:11:06.299852 | 2021-05-06T13:22:21 | 2021-05-06T13:22:21 | 60,314,071 | 1 | 3 | null | null | null | null | UTF-8 | Java | false | false | 321 | java | package com.viber.jni;
public class ViberInInfo
{
public boolean isViberInNativeCallScreen;
public boolean isViberInTestGroup;
}
/* Location: E:\Study\Tools\apktool2_2\dex2jar-0.0.9.15\classes_viber_2_dex2jar.jar
* Qualified Name: com.viber.jni.ViberInInfo
* JD-Core Version: 0.6.2
*/ | [
"[email protected]"
] | |
fa7807418c121f2c59b33bac2e6fb15fb43258b6 | dc187b0a47d5871264978934f03b71c719943779 | /src/main/java/io/nubank/github/authorizer/transaction/AccountHasLimitDecorator.java | f8dd9c89a3ac88ef9ca5cabf572a507f14cc9a59 | [] | no_license | ricardosander/transaction-authorizer | 8ace92813314c4ecbee5f5782a1b6f8ae3a93fce | 1c13a39c6d50bb30bd22ac0593b9b02e6bd04c14 | refs/heads/main | 2023-09-04T11:47:27.747429 | 2021-11-16T00:30:31 | 2021-11-16T00:30:31 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 868 | java | package io.nubank.github.authorizer.transaction;
import io.nubank.github.authorizer.account.Account;
import java.util.List;
class AccountHasLimitDecorator extends TransactionCreationViolationVerifierDecorator {
private static final String VIOLATION_NAME = "insufficient-limit";
public AccountHasLimitDecorator(TransactionCreationViolationVerifier next) {
super(next);
}
public List<String> verify(Account account, TransactionCreationRequest request) {
List<String> violations = super.verify(account, request);
if (account != null && accountDontHaveLimit(account, request)) {
violations.add(VIOLATION_NAME);
}
return violations;
}
private boolean accountDontHaveLimit(Account account, TransactionCreationRequest request) {
return !account.hasLimit(request.getAmount());
}
}
| [
"[email protected]"
] | |
1eef765a9847b382bb52fc245dee3f6ff2608c4d | be04b6ed1d923a49458418cc5ec08d8c8bc3ebd1 | /RecModel/src/main/java/com/reclabs/recomendar/model/services/communities/CommunityService.java | 3c97d56212076231bfd19dfe2877926466f906b8 | [] | no_license | franmorales86/Tests | a65747b62d1669f264b511294534853e2af6acd1 | bb06203b961827e8aac881f06de97fa7b4b0fd5d | refs/heads/master | 2021-01-11T09:17:25.039643 | 2016-12-21T22:47:27 | 2016-12-21T22:47:27 | 77,089,617 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 722 | java | /**
* Project: RecModel
* Created by: fjmorales at 05/04/2013 16:47:26
* Licensed to Recomendar Labs SL
* Recomendar Labs SL © 2012
*
* You may obtain a copy of the license at
* http://recomendarlabs.com/licenses/License
*/
package com.reclabs.recomendar.model.services.communities;
import com.reclabs.recomendar.objects.documents.communities.CommunityDTO;
import java.util.List;
/**
* @author fjmorales
*/
@Deprecated
public interface CommunityService {
List<CommunityDTO> getCommunityPriorityByCategory(String categoryId, Integer page, Integer size);
List<CommunityDTO> getVIPCommunityByCategory(String categoryId, Integer page, Integer size);
List<CommunityDTO> getCommunityPriorityVIP();
}
| [
"[email protected]"
] | |
b52298b695c75672d34438eb4b8ca9bbeb45608c | 960744b5e56de7ae2b8f1b55a69c9095d1f20e2f | /src/GameUtilities/Show_GIF.java | b18cb915b2c6c6557154bf97d3daceab9df44f11 | [] | no_license | Skelorc/OurProgrammForFunny | edd7219b901ab89633acf8025ae5783562ab0a5a | 517cbc2616246be0d9866ea3b7b57f00f28b439a | refs/heads/master | 2023-01-08T07:48:50.281159 | 2020-11-10T08:24:00 | 2020-11-10T08:24:00 | 311,592,392 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,037 | java | package GameUtilities;
import java.awt.BorderLayout;
import static java.awt.BorderLayout.CENTER;
import java.awt.Dimension;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JLabel;
public class Show_GIF {
Random random = new Random();
static ArrayList<ImageIcon> goodGif = new ArrayList<ImageIcon>();
static ArrayList<ImageIcon> badGif = new ArrayList<ImageIcon>();
private static JDialog dialogG;
private static JDialog dialogB;
private static JLabel LabelGood = new JLabel();
private static JLabel LabelBad = new JLabel();
static int g = 0;
static int b = 0;
public static void addGif()
{
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\класс.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\в очках хлопает в лодоши.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\бин врач.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\парень класс.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\все рады.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\бензопила ок.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\башкой кивает.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\лео.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\макгрэг.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\пляшут.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\радость.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\отлично.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\йес.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\танцуер.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\престол.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\десятка.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\палецвверх.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\розовая.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\респект.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\стадион.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\парк.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\лайк.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\псих.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\сталон.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\лысый класс.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\девушка класс.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\тату класс.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\в очках круто.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\девушка смеется.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\ода.gif"));
goodGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\1ZNW.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\керри не доволен.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\терминатор не правильно.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\профессор не доволен.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\печаль.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\башкой об стол.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\за башку.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\сезам.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\панда.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\девушка.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\ведущий.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\девчушка.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\седой.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\барышня.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\грозный.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\тренер.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\котэ.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\уиллсмит.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\девка.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\скайли.gif"));
badGif.add(new ImageIcon("src\\\\Materials\\\\GIF\\\\пальцемнет.gif"));
}
public static void showGoodGif()
{
if(g >= goodGif.size())
{
g=0;
}
dialogG = new JDialog();
dialogG.setTitle("Правильно!!!");
dialogG.setSize(new Dimension(250,300));
dialogG.getContentPane().setLayout(new BorderLayout());
dialogG.setResizable(false);
LabelGood = new JLabel(goodGif.get(g));
LabelGood.setLocation(70,0);
dialogG.getContentPane().add(LabelGood, CENTER);
dialogG.setLocationRelativeTo(null);
dialogG.validate();
dialogG.setVisible(true);
dialogG.getFocusOwner();
g++;
}
public static void showBadGif()
{
if(b >= badGif.size())
{
b=0;
}
dialogB = new JDialog();
dialogB.setTitle("Неверно!!!");
dialogB.setSize(new Dimension(250,300));
dialogB.getContentPane().setLayout(new BorderLayout());
dialogB.setResizable(false);
LabelBad = new JLabel(badGif.get(b));
LabelBad.setLocation(70,0);
dialogB.getContentPane().add(LabelBad, CENTER);
dialogB.setLocationRelativeTo(null);
dialogB.validate();
dialogB.setVisible(true);
b++;
}
public static void closeGif()
{
LabelGood.setVisible(false);
LabelBad.setVisible(false);
if (dialogG != null)
{
dialogG.setVisible(false);
dialogG.dispose();
}
if(dialogB != null)
{
dialogB.setVisible(false);
dialogB.dispose();
}
}
}
| [
"[email protected]"
] | |
7c29dde6f21201bedfc0b2a8caac997e2d7c2ce7 | 065c1f648e8dd061a20147ff9c0dbb6b5bc8b9be | /eclipsejdt_cluster/61949/src_1.java | 4b160902923807ddd1f4cb66eaae2633266a72f2 | [] | no_license | martinezmatias/GenPat-data-C3 | 63cfe27efee2946831139747e6c20cf952f1d6f6 | b360265a6aa3bb21bd1d64f1fc43c3b37d0da2a4 | refs/heads/master | 2022-04-25T17:59:03.905613 | 2020-04-15T14:41:34 | 2020-04-15T14:41:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 58,197 | java | /*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.core.tests.model;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.JavaModelStatus;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.UserLibraryClasspathContainer;
import junit.framework.Test;
public class ClasspathInitializerTests extends ModifyingResourceTests {
public static class DefaultVariableInitializer implements VariablesInitializer.ITestInitializer {
Map variableValues;
/*
* values is [<var name>, <var value>]*
*/
public DefaultVariableInitializer(String[] values) {
this.variableValues = new HashMap();
for (int i = 0; i < values.length; i+=2) {
this.variableValues.put(values[i], new Path(values[i+1]));
}
}
public void initialize(String variable) throws JavaModelException {
if (this.variableValues == null) return;
JavaCore.setClasspathVariable(
variable,
(IPath)this.variableValues.get(variable),
null);
}
}
// Simple container initializer, which keeps setting container to null
// (30920 - stackoverflow when setting container to null)
public class NullContainerInitializer implements ContainerInitializer.ITestInitializer {
public boolean hasRun = false;
public boolean allowFailureContainer() {
return false; // allow the initializer to run again
}
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
this.hasRun = true;
JavaCore.setClasspathContainer(
containerPath,
new IJavaProject[] {project},
new IClasspathContainer[] { null },
null);
}
}
public ClasspathInitializerTests(String name) {
super(name);
}
public static Test suite() {
return buildModelTestSuite(ClasspathInitializerTests.class);
}
// Use this static initializer to specify subset for tests
// All specified tests which do not belong to the class are skipped...
static {
// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
// TESTS_NAMES = new String[] { "testContainerInitializer12" };
// Numbers of tests to run: "test<number>" will be run for each number of this array
// TESTS_NUMBERS = new int[] { 2, 12 };
// Range numbers of tests to run: all tests between "test<first>" and "test<last>" will be run for { first, last }
// TESTS_RANGE = new int[] { 16, -1 };
}
protected void tearDown() throws Exception {
// Cleanup caches
JavaModelManager manager = JavaModelManager.getJavaModelManager();
manager.containers = new HashMap(5);
manager.variables = new HashMap(5);
super.tearDown();
}
public void testContainerInitializer01() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar"));
assertTrue("/P1/lib.jar should exist", root.exists());
} finally {
stopDeltas();
deleteProject("P1");
deleteProject("P2");
}
}
public void testContainerInitializer02() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// simulate state on startup
simulateExitRestart();
startDeltas();
p2.getResolvedClasspath(true);
assertDeltas(
"Unexpected delta on startup",
""
);
} finally {
stopDeltas();
deleteProject("P1");
deleteProject("P2");
}
}
public void testContainerInitializer03() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}));
createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// change value of TEST_CONTAINER
createFile("/P1/lib2.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib2.jar"}));
// simulate state on startup
simulateExitRestart();
startDeltas();
getJavaProject("P2").getResolvedClasspath(true);
assertDeltas(
"Unexpected delta on startup",
"P2[*]: {CHILDREN | RESOLVED CLASSPATH CHANGED}\n" +
" /P1/lib.jar[*]: {REMOVED FROM CLASSPATH}\n" +
" /P1/lib2.jar[*]: {ADDED TO CLASSPATH}"
);
} finally {
stopDeltas();
deleteProject("P1");
deleteProject("P2");
}
}
/* Ensure that initializer is not callled when resource tree is locked.
* (regression test for bug 29585 Core Exception as resource tree is locked initializing classpath container)
*/
public void testContainerInitializer04() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
DefaultContainerInitializer initializer = new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"});
ContainerInitializer.setInitializer(initializer);
createJavaProject(
"P2",
new String[] {""},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// simulate state on startup
simulateExitRestart();
startDeltas();
createFile("/P2/X.java", "public class X {}");
assertEquals("Should not get exception", null, initializer.exception);
assertDeltas(
"Unexpected delta on startup",
"P2[*]: {CHILDREN}\n" +
" <project root>[*]: {CHILDREN}\n" +
" <default>[*]: {CHILDREN}\n" +
" X.java[+]: {}"
);
} finally {
stopDeltas();
deleteProject("P1");
deleteProject("P2");
}
}
/*
* 30920 - Stack overflow when container resolved to null
*/
public void testContainerInitializer05() throws CoreException {
try {
NullContainerInitializer nullInitializer = new NullContainerInitializer();
ContainerInitializer.setInitializer(nullInitializer);
createJavaProject(
"P1",
new String[] {""},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// simulate state on startup
simulateExitRestart();
startDeltas();
// will trigger classpath resolution (with null container value)
createFile("/P1/X.java", "public class X {}");
assertDeltas(
"Unexpected delta on startup",
"P1[*]: {CHILDREN}\n" +
" <project root>[*]: {CHILDREN}\n" +
" <default>[*]: {CHILDREN}\n" +
" X.java[+]: {}"
);
assertTrue("initializer did not run", nullInitializer.hasRun);
// next cp resolution request will rerun the initializer
waitForAutoBuild();
nullInitializer.hasRun = false; // reset
getJavaProject("P1").getResolvedClasspath(true);
assertTrue("initializer did not run", nullInitializer.hasRun); // initializer should have run again (since keep setting to null)
// assigning new (non-null) value to container
waitForAutoBuild();
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}));
clearDeltas();
getJavaProject("P1").getResolvedClasspath(true);
assertDeltas(
"Unexpected delta after setting container",
"P1[*]: {CHILDREN | RESOLVED CLASSPATH CHANGED}\n" +
" lib.jar[*]: {ADDED TO CLASSPATH}"
);
} catch (StackOverflowError e) {
e.printStackTrace();
assertTrue("stack overflow assigning container", false);
} finally {
stopDeltas();
deleteProject("P1");
}
}
/*
* Ensures that running the initializer during a reconcile operation just after workspace startup
* doesn't throw a NPE
* (regression test for bug 48818 NPE in delta processor)
*/
public void testContainerInitializer06() throws CoreException {
ICompilationUnit workingCopy = null;
try {
createProject("P1");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", ""}));
createJavaProject(
"P2",
new String[] {"src"},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"bin");
createFile(
"/P2/src/X,java",
"public class X {\n" +
"}"
);
// change value of TEST_CONTAINER
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1"}));
// simulate state on startup
simulateExitRestart();
startDeltas();
workingCopy = getCompilationUnit("/P2/src/X.java");
workingCopy.becomeWorkingCopy(null);
assertWorkingCopyDeltas(
"Unexpected delta on startup",
"P2[*]: {CHILDREN}\n" +
" src[*]: {CHILDREN}\n" +
" <default>[*]: {CHILDREN}\n" +
" [Working copy] X.java[+]: {PRIMARY WORKING COPY}"
);
} finally {
stopDeltas();
if (workingCopy != null) workingCopy.discardWorkingCopy();
deleteProject("P1");
deleteProject("P2");
}
}
/*
* Ensure that an OperationCanceledException goes through
* (regression test for bug 59363 Should surface cancellation exceptions)
*/
public void testContainerInitializer07() throws CoreException {
try {
boolean gotException = false;
try {
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}) {
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
throw new OperationCanceledException("test");
}});
IJavaProject p1 = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
p1.getResolvedClasspath(true);
} catch (OperationCanceledException e) {
gotException = true;
}
assertTrue("Should get an OperationCanceledException", gotException);
} finally {
stopDeltas();
deleteProject("P1");
}
}
/*
* Ensure that the stack doesn't blow up if initializer is missbehaving
* (regression test for bug 61052 Flatten cp container initialization)
*/
public void testContainerInitializer08() throws CoreException {
final int projectLength = 10;
final String[] projects = new String[projectLength];
for (int i = 0; i < projectLength; i++) {
projects[i] = "P" + i;
}
try {
String[] projectRefs = new String[(projectLength-1) * 2];
for (int i = 0; i < projectLength-1; i++) {
projectRefs[i*2] = "P" + i;
projectRefs[(i*2)+1] = "/P" + i + "/test.jar";
}
ContainerInitializer.setInitializer(new DefaultContainerInitializer(projectRefs) {
void foo(int n) {
if (n > 0) {
foo(n-1);
return;
}
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
for (int i = 0; i < projectLength-1; i++) {
try {
JavaCore.create(root.getProject(projects[i])).getResolvedClasspath(true);
} catch (JavaModelException e) {
// project doesn't exist: ignore
}
}
}
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
foo(500);
super.initialize(containerPath, project);
}
});
JavaCore.run(new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
for (int i = 0; i < projectLength; i++) {
createProject(projects[i]);
editFile(
"/" + projects[i] + "/.project",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<projectDescription>\n" +
" <name>" + projects[i] + "</name>\n" +
" <comment></comment>\n" +
" <projects>\n" +
(i == 0 ? "" : "<project>" + projects[i-1] + "</project>\n") +
" </projects>\n" +
" <buildSpec>\n" +
" <buildCommand>\n" +
" <name>org.eclipse.jdt.core.javabuilder</name>\n" +
" <arguments>\n" +
" </arguments>\n" +
" </buildCommand>\n" +
" </buildSpec>\n" +
" <natures>\n" +
" <nature>org.eclipse.jdt.core.javanature</nature>\n" +
" </natures>\n" +
"</projectDescription>"
);
createFile(
"/" + projects[i] + "/.classpath",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<classpath>\n" +
(i == 0 ? "" : "<classpathentry kind=\"src\" path=\"/" + projects[i-1] + "\"/>\n") +
" <classpathentry kind=\"con\" path=\"org.eclipse.jdt.core.tests.model.TEST_CONTAINER\"/>\n" +
" <classpathentry kind=\"output\" path=\"\"/>\n" +
"</classpath>"
);
}
}
}, null);
getJavaProject("P0").getResolvedClasspath(true);
} finally {
stopDeltas();
deleteProjects(projects);
}
}
/*
* Ensure that a StackOverFlowError is not thrown if the initializer asks for the resolved classpath
* that is being resolved.
* (regression test for bug 61040 Should add protect for reentrance to #getResolvedClasspath)
*/
public void testContainerInitializer09() throws CoreException {
try {
DefaultContainerInitializer initializer = new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}) {
protected DefaultContainer newContainer(char[][] libPaths) {
return new DefaultContainer(libPaths) {
public IClasspathEntry[] getClasspathEntries() {
try {
getJavaProject("P1").getResolvedClasspath(true);
} catch (JavaModelException e) {
// project doesn't exist: ignore
}
return super.getClasspathEntries();
}
};
}
};
ContainerInitializer.setInitializer(initializer);
JavaCore.run(new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
createProject("P1");
editFile(
"/P1/.project",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<projectDescription>\n" +
" <name>P1</name>\n" +
" <comment></comment>\n" +
" <projects>\n" +
" </projects>\n" +
" <buildSpec>\n" +
" <buildCommand>\n" +
" <name>org.eclipse.jdt.core.javabuilder</name>\n" +
" <arguments>\n" +
" </arguments>\n" +
" </buildCommand>\n" +
" </buildSpec>\n" +
" <natures>\n" +
" <nature>org.eclipse.jdt.core.javanature</nature>\n" +
" </natures>\n" +
"</projectDescription>"
);
createFile(
"/P1/.classpath",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<classpath>\n" +
" <classpathentry kind=\"con\" path=\"org.eclipse.jdt.core.tests.model.TEST_CONTAINER\"/>\n" +
" <classpathentry kind=\"output\" path=\"\"/>\n" +
"</classpath>"
);
}
}, null);
getJavaProject("P1").getResolvedClasspath(true);
} finally {
stopDeltas();
ContainerInitializer.setInitializer(null);
deleteProject("P1");
}
}
/*
* Ensure that creating a Java project initializes a container and refreshes the external jar at the same time
* without throwing a ConcurrentModificationException
* (regression test for bug 63534 ConcurrentModificationException after "catching up")
*/
public void testContainerInitializer10() throws CoreException {
class LogListener implements ILogListener {
IStatus log;
public void logging(IStatus status, String plugin) {
this.log = status;
}
}
LogListener listener = new LogListener();
try {
Platform.addLogListener(listener);
final IJavaProject p1 = createJavaProject("P1");
final IJavaProject p2 = createJavaProject("P2");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P3", "/P1"}) {
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
super.initialize(containerPath, project);
getJavaModel().refreshExternalArchives(new IJavaElement[] {p1}, null);
}
});
getWorkspace().run(new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
p2.setRawClasspath(new IClasspathEntry[] {JavaCore.newSourceEntry(new Path("/P2/src"))}, new Path("/P2/bin"), null);
createProject("P3");
editFile(
"/P3/.project",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<projectDescription>\n" +
" <name>P3</name>\n" +
" <comment></comment>\n" +
" <projects>\n" +
" </projects>\n" +
" <buildSpec>\n" +
" <buildCommand>\n" +
" <name>org.eclipse.jdt.core.javabuilder</name>\n" +
" <arguments>\n" +
" </arguments>\n" +
" </buildCommand>\n" +
" </buildSpec>\n" +
" <natures>\n" +
" <nature>org.eclipse.jdt.core.javanature</nature>\n" +
" </natures>\n" +
"</projectDescription>\n"
);
createFile(
"/P3/.classpath",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<classpath>\n" +
" <classpathentry kind=\"src\" path=\"\"/>\n" +
" <classpathentry kind=\"var\" path=\"JCL_LIB\"/>\n" +
" <classpathentry kind=\"con\" path=\"org.eclipse.jdt.core.tests.model.TEST_CONTAINER\"/>\n" +
" <classpathentry kind=\"output\" path=\"\"/>\n" +
"</classpath>"
);
}
}, null);
assertEquals("Should not get any exception in log", null, listener.log);
} finally {
Platform.removeLogListener(listener);
deleteProject("P1");
deleteProject("P2");
deleteProject("P3");
}
}
/*
* Ensure that a classpath initializer is not run on shutdown
* (regression test for bug 93941 Classpath initialization on shutdown)
*/
public void testContainerInitializer11() throws CoreException {
boolean hasExited = false;
try {
ContainerInitializer.setInitializer(null);
createJavaProject(
"P",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
simulateExitRestart();
DefaultContainerInitializer initializer = new DefaultContainerInitializer(new String[] {}) {
public void initialize(IPath containerPath,IJavaProject project) throws CoreException {
assertTrue("Should not initialize container on shutdown", false);
}
};
ContainerInitializer.setInitializer(initializer);
simulateExit();
hasExited = true;
} finally {
ContainerInitializer.setInitializer(null);
if (hasExited)
simulateRestart();
deleteProject("P");
}
}
/*
* Ensure that the initializer is removed from the cache when the project is deleted
* (regression test for bug 116072 cached classpath containers not removed when project deleted)
*/
public void testContainerInitializer12() throws CoreException {
try {
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}));
IJavaProject project = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
createFile("/P1/lib.jar", "");
IPackageFragmentRoot root = project.getPackageFragmentRoot(getFile("/P1/lib.jar"));
assertTrue("/P1/lib.jar should exist", root.exists());
deleteProject("P1");
class Initializer extends DefaultContainerInitializer {
boolean initialized;
public Initializer(String[] args) {
super(args);
}
public void initialize(IPath containerPath, IJavaProject p) throws CoreException {
super.initialize(containerPath, p);
this.initialized = true;
}
}
Initializer initializer = new Initializer(new String[] {"P1", "/P1/lib.jar"});
ContainerInitializer.setInitializer(initializer);
createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
createFile("/P1/lib.jar", "");
assertTrue("/P1/lib.jar should exist", root.exists());
assertTrue("Should have been initialized", initializer.initialized);
} finally {
stopDeltas();
deleteProject("P1");
}
}
/*
* Ensures that no resource deta is reported if a container that was not initialized is initialized with null
* (regression test for bug 149043 Unresolvable classpath container leads to lots of scheduled jobs)
*/
public void testContainerInitializer13() throws CoreException {
IResourceChangeListener listener = new IResourceChangeListener() {
StringBuffer buffer = new StringBuffer();
public void resourceChanged(IResourceChangeEvent event) {
this.buffer.append(event.getDelta().findMember(new Path("/P1")));
}
public String toString() {
return this.buffer.toString();
}
};
try {
NullContainerInitializer nullInitializer = new NullContainerInitializer();
ContainerInitializer.setInitializer(nullInitializer);
IJavaProject project = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// simulate state on startup
simulateExitRestart();
getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_CHANGE);
// force resolution of container
project.findPackageFragmentRoots(project.getRawClasspath()[0]);
assertEquals(
"Unexpected resource delta on startup",
"",
listener.toString()
);
} finally {
getWorkspace().removeResourceChangeListener(listener);
deleteProject("P1");
}
}
/*
* Ensures that a misbehaving container (that initializes another project than the one asked for) doesn't cause
* the container to be initialized again
* (regression test for bug 160005 Add protection about misbehaving container initializer)
*/
public void testContainerInitializer14() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
class Container extends DefaultContainerInitializer {
int initializeCount = 0;
Container(String[] values) {
super(values);
}
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
this.initializeCount++;
super.initialize(containerPath, getJavaProject("P1"));
}
}
Container container = new Container(new String[] {"P2", "/P1/lib.jar"});
ContainerInitializer.setInitializer(container);
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
p2.getResolvedClasspath(true);
assertEquals("Unexpected number of initalizations", 1, container.initializeCount);
} finally {
stopDeltas();
deleteProject("P1");
deleteProject("P2");
}
}
/*
* Ensures that if a container is misbehaving (it doesn't initialize a project when asked for),
* then the resulting container's classpath is not null
* (regression test for bug 161846 Expanding a java project with invalid classpath container entries in Project Explorer causes CPU to stay at 100%)
*/
public void testContainerInitializer15() throws CoreException {
try {
class Container extends DefaultContainerInitializer {
Container(String[] values) {
super(values);
}
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
}
}
Container container = new Container(new String[] {"P1", "/P1/lib.jar"});
ContainerInitializer.setInitializer(container);
IJavaProject p1 = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
IClasspathContainer classpathContainer = JavaCore.getClasspathContainer(new Path("org.eclipse.jdt.core.tests.model.TEST_CONTAINER"), p1);
assertClasspathEquals(classpathContainer.getClasspathEntries(), "");
} finally {
stopDeltas();
deleteProject("P1");
}
}
/*
* Ensure that an initializer cannot return a project entry that points to the project of the container (cycle).
*/
public void testContainerInitializer16() throws CoreException {
try {
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1"}));
JavaModelException exception = null;
try {
IJavaProject p1 = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
p1.getResolvedClasspath(true);
} catch (JavaModelException e) {
exception = e;
}
assertExceptionEquals(
"Unexpected expection",
"Project 'P1' cannot reference itself",
exception);
} finally {
stopDeltas();
deleteProject("P1");
}
}
/*
* Ensures that no resource deta is reported if a container is initialized right after startup to the same value it had before shutdown.
* (regression test for bug 175849 Project is touched on restart)
*/
public void testContainerInitializer17() throws CoreException {
IResourceChangeListener listener = new IResourceChangeListener() {
StringBuffer buffer = new StringBuffer();
public void resourceChanged(IResourceChangeEvent event) {
this.buffer.append(event.getDelta().findMember(new Path("/P2")));
}
public String toString() {
return this.buffer.toString();
}
};
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar", "P3", "/P1/lib.jar"}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
createJavaProject(
"P3",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
// simulate state on startup
simulateExitRestart();
getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_CHANGE);
// initialize to the same value
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar", "P3", "/P1/lib.jar"}) {
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
// simulate concurrency (another thread is initializing all containers in parallel and thus this flag is set to true)
JavaModelManager.getJavaModelManager().batchContainerInitializations = JavaModelManager.NEED_BATCH_INITIALIZATION;
super.initialize(containerPath, project);
}
});
p2.getResolvedClasspath(true);
assertEquals(
"Unexpected resource delta on container initialization",
"",
listener.toString()
);
} finally {
getWorkspace().removeResourceChangeListener(listener);
deleteProject("P1");
deleteProject("P2");
deleteProject("P3");
}
}
/*
* Ensures that an unbound container marker is created if container is reset to null
* (regression test for 182204 Deleting a JRE referenced by container does not result in unbound container problem)
*/
public void testContainerInitializer18() throws CoreException {
try {
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}));
IJavaProject p1 = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
createFile("/P1/lib.jar", "");
p1.getResolvedClasspath(true);
waitForAutoBuild();
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[0]));
JavaCore.setClasspathContainer(new Path("org.eclipse.jdt.core.tests.model.TEST_CONTAINER"), new IJavaProject[] {p1}, new IClasspathContainer[] {null}, null);
assertMarkers(
"Unexpected markers",
"Unbound classpath container: \'org.eclipse.jdt.core.tests.model.TEST_CONTAINER\' in project \'P1\'",
p1);
} finally {
deleteProject("P1");
}
}
/*
* Ensures that a container is not kept in the cache if no longer referenced on the classpath
* (regression test for 139446 [build path] bug in the Edit Library dialog box, when changing the default JRE, and switching from alternate JRE to workspace default)
*/
public void testContainerInitializer19() throws CoreException {
try {
// setup
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib1.jar"}));
IJavaProject p1 = createJavaProject(
"P1",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
createFile("/P1/lib1.jar", "");
createFile("/P1/lib2.jar", "");
p1.getResolvedClasspath(true);
IClasspathEntry[] initialClasspath = p1.getRawClasspath();
// remove reference to container, change initializer, and add reference to container back
p1.setRawClasspath(new IClasspathEntry[0], null);
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib2.jar"}));
p1.setRawClasspath(initialClasspath, null);
assertClasspathEquals(
p1.getResolvedClasspath(true),
"/P1/lib2.jar[CPE_LIBRARY][K_BINARY][isExported:false]"
);
} finally {
deleteProject("P1");
}
}
/*
* Ensures that container a container is not kept in the cache if no longer referenced on the classpath
* (regression test for 136382 [classpath] Discard container if not referenced on classpath)
*/
public void testContainerInitializer20() throws CoreException {
try {
IJavaProject p = createJavaProject("P");
final StringBuffer paths = new StringBuffer();
DefaultContainerInitializer initializer = new DefaultContainerInitializer(new String[] {"P", "/P/lib.jar"}) {
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
paths.append(containerPath);
paths.append('\n');
super.initialize(containerPath, project);
}
};
ContainerInitializer.setInitializer(initializer);
setClasspath(p, new IClasspathEntry[] {JavaCore.newContainerEntry(new Path("org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE1"))});
setClasspath(p, new IClasspathEntry[] {JavaCore.newContainerEntry(new Path("org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE2"))});
setClasspath(p, new IClasspathEntry[] {JavaCore.newContainerEntry(new Path("org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE1"))});
assertStringEquals(
"org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE1\n" +
"org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE2\n" +
"org.eclipse.jdt.core.tests.model.TEST_CONTAINER/JRE1\n",
paths.toString(),
false);
} finally {
stopDeltas();
deleteProject("P");
}
}
public void testContainerInitializer21() throws CoreException {
try {
createProject("P1");
createExternalFolder("externalLib");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib")}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib"));
assertTrue(getExternalResourcePath("externalLib") + " should exist", root.exists());
} finally {
stopDeltas();
deleteExternalResource("externalLib");
deleteProject("P1");
deleteProject("P2");
}
}
public void testContainerInitializer22() throws CoreException {
try {
createProject("P1");
createExternalFile("externalLib.abc", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib.abc")}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib.abc"));
assertTrue(getExternalResourcePath("externalLib.abc") + " should exist", root.exists());
} finally {
stopDeltas();
deleteExternalResource("externalLib.abc");
deleteProject("P1");
deleteProject("P2");
}
}
public void testContainerInitializer23() throws CoreException {
try {
createProject("P1");
IFile lib = createFile("/P1/internalLib.abc", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/internalLib.abc"}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(lib);
assertTrue("/P1/internalLib.abc should exist", root.exists());
} finally {
stopDeltas();
deleteExternalResource("externalLib.abc");
deleteProject("P1");
deleteProject("P2");
}
}
/*
* Ensures that the value of a resolved classpath is correct if another thread is resolving the classpath concurrently
* (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=232478 )
*/
public void testContainerInitializer24() throws Exception {
BPThread.TIMEOUT = 30000; // wait 30s max
BPThread thread = new BPThread("getResolvedClasspath()");
ClasspathResolutionBreakpointListener listener = new ClasspathResolutionBreakpointListener(new BPThread[] {thread});
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}));
final JavaProject project2 = (JavaProject) createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
simulateExit();
deleteResource(JavaCore.getPlugin().getStateLocation().append("variablesAndContainers.dat").toFile());
simulateRestart();
JavaProject.addCPResolutionBPListener(listener);
thread.start(new Runnable() {
public void run() {
try {
project2.getResolvedClasspath();
} catch (JavaModelException e) {
e.printStackTrace();
}
}
});
thread.runToBP(1);
thread.runToBP(2);
thread.runToBP(3);
IClasspathEntry[] classpath = project2.getResolvedClasspath();
assertClasspathEquals(
classpath,
"/P1/lib.jar[CPE_LIBRARY][K_BINARY][isExported:false]"
);
} finally {
JavaProject.removeCPResolutionBPListener(listener);
thread.runToEnd();
deleteProjects(new String[] {"P1", "P2"});
}
}
/*
* Ensures that the project references are updated on startup if the initializer gives a different value.
*/
public void testContainerInitializer25() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}));
IJavaProject p2 = createJavaProject(
"P2",
new String[] {},
new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
"");
ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1"}));
// simulate state on startup
simulateExitRestart();
p2.getResolvedClasspath(true);
assertResourcesEqual(
"Unexpected project references on startup",
"/P1",
p2.getProject().getDescription().getDynamicReferences());
} finally {
deleteProject("P1");
deleteProject("P2");
}
}
public void testVariableInitializer01() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}));
IJavaProject p2 = createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB"}, "");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar"));
assertTrue("/P1/lib.jar should exist", root.exists());
} finally {
deleteProject("P1");
deleteProject("P2");
VariablesInitializer.reset();
}
}
public void testVariableInitializer02() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
createFile("/P1/src.zip", "");
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {
"TEST_LIB", "/P1/lib.jar",
"TEST_SRC", "/P1/src.zip",
"TEST_ROOT", "src",
}));
IJavaProject p2 = createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}, "");
IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar"));
assertEquals("Unexpected source attachment path", "/P1/src.zip", root.getSourceAttachmentPath().toString());
assertEquals("Unexpected source attachment root path", "src", root.getSourceAttachmentRootPath().toString());
} finally {
deleteProject("P1");
deleteProject("P2");
VariablesInitializer.reset();
}
}
public void testVariableInitializer03() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
createFile("/P1/src.zip", "");
String[] variableValues = new String[] {
"TEST_LIB", "/P1/lib.jar",
"TEST_SRC", "/P1/src.zip",
"TEST_ROOT", "src",
};
VariablesInitializer.setInitializer(new DefaultVariableInitializer(variableValues));
createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}, "");
// simulate state on startup
simulateExitRestart();
startDeltas();
//JavaModelManager.CP_RESOLVE_VERBOSE=true;
getJavaProject("P2").getResolvedClasspath(true);
assertDeltas(
"Unexpected delta on startup",
""
);
} finally {
//JavaModelManager.CP_RESOLVE_VERBOSE=false;
stopDeltas();
deleteProject("P1");
deleteProject("P2");
VariablesInitializer.reset();
}
}
public void testVariableInitializer04() throws CoreException {
try {
final StringBuffer buffer = new StringBuffer();
VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() {
public void initialize(String variable) throws JavaModelException {
buffer.append("Initializing " + variable + "\n");
IPath path = new Path(variable.toLowerCase());
buffer.append("Setting variable " + variable + " to " + path + "\n");
JavaCore.setClasspathVariable(variable, path, null);
}
});
createJavaProject("P", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}, "");
assertEquals(
"Initializing TEST_LIB\n" +
"Setting variable TEST_LIB to test_lib\n",
buffer.toString());
} finally {
deleteProject("P");
VariablesInitializer.reset();
}
}
public void testVariableInitializer05() throws CoreException {
try {
final StringBuffer buffer = new StringBuffer();
VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() {
public void initialize(String variable) throws JavaModelException {
buffer.append("Initializing " + variable + "\n");
IPath path = new Path(variable.toLowerCase());
JavaCore.getClasspathVariable("TEST_SRC");
buffer.append("Setting variable " + variable + " to " + path + "\n");
JavaCore.setClasspathVariable(variable, path, null);
}
});
createJavaProject("P", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}, "");
assertEquals(
"Initializing TEST_LIB\n" +
"Initializing TEST_SRC\n" +
"Setting variable TEST_SRC to test_src\n" +
"Setting variable TEST_LIB to test_lib\n",
buffer.toString());
} finally {
deleteProject("P");
VariablesInitializer.reset();
}
}
/*
* Ensures that if the initializer doesn't initialize a variable, it can be
* initialized later on.
*/
public void testVariableInitializer06() throws CoreException {
try {
final StringBuffer buffer = new StringBuffer();
VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() {
public void initialize(String variable) {
// do nothing
buffer.append("Ignoring request to initialize");
}
});
IPath path = JavaCore.getClasspathVariable("TEST_SRC");
assertEquals(
"Unexpected value of TEST_SRC after initializer was called",
null,
path);
IPath varValue = new Path("src.zip");
JavaCore.setClasspathVariable("TEST_SRC", varValue, null);
path = JavaCore.getClasspathVariable("TEST_SRC");
assertEquals(
"Unexpected value of TEST_SRC after setting it",
varValue,
path);
} finally {
VariablesInitializer.reset();
}
}
public void testVariableInitializer07() throws CoreException {
try {
createProject("P1");
createFile("/P1/lib.jar", "");
createFile("/P1/src.zip", "");
String[] variableValues = new String[] {
"TEST_LIB", "/P1/lib.jar",
"TEST_SRC", "/P1/src.zip",
"TEST_ROOT", "src",
};
VariablesInitializer.setInitializer(new DefaultVariableInitializer(variableValues));
createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}, "");
// change value of TEST_LIB
createFile("/P1/lib2.jar", "");
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {
"TEST_LIB", "/P1/lib2.jar",
"TEST_SRC", "/P1/src.zip",
"TEST_ROOT", "src",
}));
// simulate state on startup
simulateExitRestart();
startDeltas();
//JavaModelManager.CP_RESOLVE_VERBOSE=true;
getJavaProject("P2").getResolvedClasspath(true);
assertDeltas(
"Unexpected delta on startup",
"P2[*]: {CHILDREN | RESOLVED CLASSPATH CHANGED}\n" +
" /P1/lib.jar[*]: {REMOVED FROM CLASSPATH}\n" +
" /P1/lib2.jar[*]: {ADDED TO CLASSPATH}"
);
} finally {
//JavaModelManager.CP_RESOLVE_VERBOSE=false;
stopDeltas();
deleteProject("P1");
deleteProject("P2");
VariablesInitializer.reset();
}
}
/*
* Ensure that an OperationCanceledException goes through
* (regression test for bug 59363 Should surface cancellation exceptions)
*/
public void testVariableInitializer08() throws CoreException {
try {
boolean gotException = false;
try {
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) {
public void initialize(String variable) throws JavaModelException {
throw new OperationCanceledException("test");
}
});
IJavaProject p1 = createJavaProject("P1", new String[] {}, new String[] {"TEST_LIB"}, "");
p1.getResolvedClasspath(true);
} catch (OperationCanceledException e) {
gotException = true;
}
assertTrue("Should get an OperationCanceledException", gotException);
} finally {
deleteProject("P1");
VariablesInitializer.reset();
}
}
/*
* Ensure that removing a classpath variable while initializing it doesn't throw a StackOverFlowError
* (regression test for bug 112609 StackOverflow when initializing Java Core)
*/
public void testVariableInitializer09() throws CoreException {
try {
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) {
public void initialize(String variable) throws JavaModelException {
JavaCore.removeClasspathVariable("TEST_LIB", null);
}
});
IJavaProject p1 = createJavaProject("P1", new String[] {}, new String[] {"TEST_LIB"}, "");
IClasspathEntry[] resolvedClasspath = p1.getResolvedClasspath(true);
assertClasspathEquals(
resolvedClasspath,
""
);
} finally {
deleteProject("P1");
VariablesInitializer.reset();
}
}
/*
* Ensures that not initializing a classpath variable and asking for its value returns null
* (regression test for bug 113110 TestFailures in DebugSuite)
*/
public void testVariableInitializer10() throws CoreException {
try {
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) {
public void initialize(String variable) throws JavaModelException {
// don't initialize
}
});
// force resolution
JavaCore.getClasspathVariable("TEST_LIB");
// second call should still be null
assertEquals("TEST_LIB should be null", null, JavaCore.getClasspathVariable("TEST_LIB"));
} finally {
deleteProject("P1");
VariablesInitializer.reset();
}
}
/**
* Bug 125965: [prefs] "Export/Import preferences" should let user to choose wich preference to export/import
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=125965"
*/
public void testVariableInitializer11() throws CoreException {
try {
// Create initializer
String varName = "TEST_LIB";
String initialValue = "/P1/lib.jar";
String newValue = "/tmp/file.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, initialValue}));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), initialValue);
// Modify preference
JavaModelManager manager = JavaModelManager.getJavaModelManager();
IEclipsePreferences preferences = manager.getInstancePreferences();
preferences.put(JavaModelManager.CP_VARIABLE_PREFERENCES_PREFIX+varName, newValue);
// verify that JavaCore preferences have been reset
assertEquals("JavaCore classpath value should be unchanged", JavaCore.getClasspathVariable(varName).toString(), initialValue);
assertEquals("JavaCore preferences value should be unchanged", preferences.get(varName, "X"), initialValue);
} finally {
VariablesInitializer.reset();
}
}
/**
* @bug 138599: [model][classpath] Need a way to mark a classpath variable as deprecated
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=138599"
*/
public void testVariableInitializerDeprecated() throws CoreException {
try {
// Create initializer
String varName = "TEST_DEPRECATED";
String filePath = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, filePath}));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), filePath);
// Verify that Classpath Variable is deprecated
assertEquals("JavaCore classpath variable should be deprecated", "Test deprecated flag", JavaCore.getClasspathVariableDeprecationMessage(varName));
// Create project
IJavaProject project = createJavaProject("P1");
createFile("/P1/lib.jar", "");
IClasspathEntry variable = JavaCore.newVariableEntry(new Path("TEST_DEPRECATED"), null, null);
IJavaModelStatus status = JavaConventions.validateClasspathEntry(project, variable, false);
assertStatus("Classpath variable 'TEST_DEPRECATED' in project 'P1' is deprecated: Test deprecated flag", status);
assertFalse("Status should not be OK", status.isOK());
assertEquals("Status should have WARNING severity", IStatus.WARNING, status.getSeverity());
assertEquals("Status should have deprecated code", IJavaModelStatusConstants.DEPRECATED_VARIABLE, status.getCode());
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
public void testVariableInitializerUnboundAndDeprecated() throws CoreException {
try {
// Create initializer
String varName = "TEST_DEPRECATED";
String filePath = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, filePath}));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), filePath);
// Verify that Classpath Variable is deprecated
assertEquals("JavaCore classpath variable should be deprecated", "Test deprecated flag", JavaCore.getClasspathVariableDeprecationMessage(varName));
// Create project
IJavaProject project = createJavaProject("P1");
IClasspathEntry variable = JavaCore.newVariableEntry(new Path("TEST_DEPRECATED"), null, null);
IJavaModelStatus status = JavaConventions.validateClasspathEntry(project, variable, false);
assertStatus("Project 'P1' is missing required library: 'lib.jar'", status);
assertFalse("Status should not be OK", status.isOK());
assertEquals("Status should have WARNING severity", IStatus.ERROR, status.getSeverity());
assertEquals("Status should have deprecated code", IJavaModelStatusConstants.INVALID_CLASSPATH, status.getCode());
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
/**
* @bug 156226: [model][classpath] Allow classpath variable to be marked as non modifiable
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=156226"
*/
public void testVariableInitializerReadOnly() throws CoreException {
try {
// Create initializer
String varName = "TEST_READ_ONLY";
String path = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path }));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), path);
// verify that Classpath Variable is read-only
assertTrue("JavaCore classpath variable should be read-only", JavaCore.isClasspathVariableReadOnly(varName));
// Create project
IJavaProject project = createJavaProject("P1");
createFile("/P1/lib.jar", "");
IClasspathEntry variable = JavaCore.newVariableEntry(new Path("TEST_READ_ONLY"), null, null);
IJavaModelStatus status = JavaConventions.validateClasspathEntry(project, variable, false);
assertStatus("OK", status);
assertTrue("Status should be OK", status.isOK());
assertEquals("Status should be VERIFIED_OK", JavaModelStatus.VERIFIED_OK, status);
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
public void testVariableInitializerDeprecatedAndReadOnly() throws CoreException {
try {
// Create initializer
String varName = "TEST_DEPRECATED_READ_ONLY";
String path = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path }));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), path);
// verify that Classpath Variable is read-only
assertEquals("JavaCore classpath variable should be deprecated", "A deprecated and read-only initializer", JavaCore.getClasspathVariableDeprecationMessage(varName));
assertTrue("JavaCore classpath variable should be read-only", JavaCore.isClasspathVariableReadOnly(varName));
// Create project
IJavaProject project = createJavaProject("P1");
createFile("/P1/lib.jar", "");
IClasspathEntry variable = JavaCore.newVariableEntry(new Path("TEST_DEPRECATED_READ_ONLY"), null, null);
IJavaModelStatus status = JavaConventions.validateClasspathEntry(project, variable, false);
assertStatus("Classpath variable 'TEST_DEPRECATED_READ_ONLY' in project 'P1' is deprecated: A deprecated and read-only initializer", status);
assertFalse("Status should not be OK", status.isOK());
assertEquals("Status should have WARNING severity", IStatus.WARNING, status.getSeverity());
assertEquals("Status should have deprecated code", IJavaModelStatusConstants.DEPRECATED_VARIABLE, status.getCode());
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
/**
* @bug 172207: [model] Marker for deprecated classpath variable should always have WARNING severity
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=172207"
*/
public void testVariableInitializerBug172207() throws CoreException {
try {
// Create initializer
String varName = "TEST_DEPRECATED_READ_ONLY";
String path = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path }));
assertEquals("JavaCore classpath value should have been initialized", JavaCore.getClasspathVariable(varName).toString(), path);
// verify that Classpath Variable is read-only
assertEquals("JavaCore classpath variable should be deprecated", "A deprecated and read-only initializer", JavaCore.getClasspathVariableDeprecationMessage(varName));
assertTrue("JavaCore classpath variable should be read-only", JavaCore.isClasspathVariableReadOnly(varName));
// Create project
IJavaProject project = createJavaProject("P1");
createFile("/P1/lib.jar", "");
IClasspathEntry variable = JavaCore.newVariableEntry(new Path("TEST_DEPRECATED_READ_ONLY"), null, null);
IClasspathEntry[] entries = project.getRawClasspath();
int length = entries.length;
System.arraycopy(entries, 0, entries = new IClasspathEntry[length+1], 0, length);
entries[length] = variable;
project.setRawClasspath(entries, null);
// verify markers
waitForAutoBuild();
IMarker[] markers = project.getProject().findMarkers(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO);
sortMarkers(markers);
assertMarkers("Unexpected marker(s)",
"Classpath variable 'TEST_DEPRECATED_READ_ONLY' in project 'P1' is deprecated: A deprecated and read-only initializer",
markers);
assertEquals("Marker on deprecated variable should be a WARNING", IMarker.SEVERITY_WARNING, markers[0].getAttribute(IMarker.SEVERITY, -1));
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
/**
* @bug 186113: [model] classpath variable deprecation messages not initialized when called
* @test a) Verify that deprecation message can be get through {@link JavaCore#getClasspathVariableDeprecationMessage(String)}
* even if the variable initializer was not called before
* b) Verify that message is not stored in cache when variable is not initialized (othwerise we could not free it up...)
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=186113"
*/
public void testVariableInitializerBug186113a() throws CoreException {
assertEquals("Invalid deprecation message!",
"Test deprecated flag",
JavaCore.getClasspathVariableDeprecationMessage("TEST_DEPRECATED")
);
}
public void testVariableInitializerBug186113b() throws CoreException {
JavaCore.getClasspathVariableDeprecationMessage("TEST_DEPRECATED");
assertNull("Deprecation message should not have been stored!", JavaModelManager.getJavaModelManager().deprecatedVariables.get("TEST_DEPRECATED"));
}
/**
* @bug 200449: [model] classpath variable deprecation messages not initialized when called
* @test a) Verify that deprecation message is well stored in cache when variable is iniatialized
* b) Verify that deprecation message is well removed in cache when variable is removed
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=200449"
*/
public void testVariableInitializerBug200449() throws CoreException {
try {
// Create initializer
String varName = "TEST_DEPRECATED";
String filePath = "/P1/lib.jar";
VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, filePath}));
JavaCore.getClasspathVariable(varName); // init variable
// Verify that deprecation message has been stored
assertNotNull("Deprecation message should have been stored!", JavaModelManager.getJavaModelManager().deprecatedVariables.get("TEST_DEPRECATED"));
} finally {
VariablesInitializer.reset();
deleteProject("P1");
}
}
public void testVariableInitializerBug200449b() throws CoreException {
// Verify that deprecated variable has been removed
assertNull("Deprecation message should have been removed!", JavaModelManager.getJavaModelManager().deprecatedVariables.get("TEST_DEPRECATED"));
}
/**
* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=61872"
*/
public void testUserLibraryInitializer1() throws CoreException {
try {
// Create new user library "SWT"
ClasspathContainerInitializer initializer= JavaCore.getClasspathContainerInitializer(JavaCore.USER_LIBRARY_CONTAINER_ID);
String libraryName = "SWT";
IPath containerPath = new Path(JavaCore.USER_LIBRARY_CONTAINER_ID);
UserLibraryClasspathContainer containerSuggestion = new UserLibraryClasspathContainer(libraryName);
initializer.requestClasspathContainerUpdate(containerPath.append(libraryName), null, containerSuggestion);
// Create java project
createJavaProject("p61872");
IFile jarFile = createFile("/p61872/swt.jar", "");
IFile srcFile = createFile("/p61872/swtsrc.zip", "");
// Modify user library
Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
String propertyName = JavaModelManager.CP_USERLIBRARY_PREFERENCES_PREFIX+"SWT";
StringBuffer propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive");
String jarFullPath = getWorkspaceRoot().getLocation().append(jarFile.getFullPath()).toString();
propertyValue.append(" path=\""+jarFullPath);
propertyValue.append("\"/>\r\n</userlibrary>\r\n");
preferences.setValue(propertyName, propertyValue.toString());
JavaCore.getPlugin().savePluginPreferences();
// Modify project classpath
editFile(
"/p61872/.classpath",
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<classpath>\n" +
" <classpathentry kind=\"con\" path=\"org.eclipse.jdt.USER_LIBRARY/SWT\"/>\n" +
" <classpathentry kind=\"output\" path=\"\"/>\n" +
"</classpath>"
);
// Verify
IClasspathEntry[] entries = getJavaProject("p61872").getResolvedClasspath(true);
assertEquals("Invalid entries number in resolved classpath for project p61872!", 1, entries.length);
assertEquals("Invalid path for project 61872 classpath entry!", jarFullPath.toLowerCase(), entries[0].getPath().toString().toLowerCase());
assertNull("Project 61872 classpath entry should not have any source attached!", entries[0].getSourceAttachmentPath());
// Modify user library
propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive");
String srcFullPath = getWorkspaceRoot().getLocation().append(srcFile.getFullPath()).toString();
propertyValue.append(" sourceattachment=\""+srcFullPath);
propertyValue.append("\" path=\""+jarFullPath);
propertyValue.append("\"/>\r\n</userlibrary>\r\n");
preferences.setValue(propertyName, propertyValue.toString());
JavaCore.getPlugin().savePluginPreferences();
// Verify
entries = getJavaProject("p61872").getResolvedClasspath(true);
assertEquals("Invalid entries number in resolved classpath for project p61872!", 1, entries.length);
assertEquals("Invalid path for project 61872 classpath entry!", jarFullPath.toLowerCase(), entries[0].getPath().toString().toLowerCase());
assertEquals("Invalid source attachement path for project 61872 classpath entry!", srcFullPath.toLowerCase(), entries[0].getSourceAttachmentPath().toString().toLowerCase());
} finally {
deleteProject("p61872");
}
}
}
| [
"[email protected]"
] | |
48c7bad11a67dfacbfb0e6aa609af499a9c9beab | 7b733d7be68f0fa4df79359b57e814f5253fc72d | /modules/ServerUIComponents/src/main/java/com/percussion/guitools/PSCalendarDialog.java | cec53f4ad42798a185dc9f0b17288aea01c99d58 | [
"LicenseRef-scancode-dco-1.1",
"Apache-2.0",
"OFL-1.1",
"LGPL-2.0-or-later"
] | permissive | percussion/percussioncms | 318ac0ef62dce12eb96acf65fc658775d15d95ad | c8527de53c626097d589dc28dba4a4b5d6e4dd2b | refs/heads/development | 2023-08-31T14:34:09.593627 | 2023-08-31T14:04:23 | 2023-08-31T14:04:23 | 331,373,975 | 18 | 6 | Apache-2.0 | 2023-09-14T21:29:25 | 2021-01-20T17:03:38 | Java | UTF-8 | Java | false | false | 34,178 | java | /*
* Copyright 1999-2023 Percussion Software, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.percussion.guitools;
import javax.accessibility.AccessibleContext;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
/**
* Calendar dialog for the user to point and click
* to enter the date.
* <p>
* Example usage:
* </p>
* <p>
* <pre>
* <code>
* PSCalendarDialog dialog = new PSCalendarDialog(ownerFrame);
* dialog.setDate(theDate); // Set the dialog to its initial date
* dialog.center(); // Center the dialog on the screen
* dialog.show(); // Display the dialog
*
* if(dialog.isDateSelected())
* setDate(dialog.getDate());
* </code>
* </pre>
* </p>
* <p>
* If the date is not set or is <code>null</code>, then the
* calendar will use today's date as the initial date.
* </p>
*/
public class PSCalendarDialog extends JDialog
{
/**
* Creates a new modal CalendarDialog
* @param owner the frame that owns this dialog
*/
PSCalendarDialog(Frame owner)
{
super(owner, true);
init();
}
/**
* Initialize the gui components
*/
private void init()
{
setTitle(ms_res.getString("calendar.dialog.title"));
Container contentPane = getContentPane();
contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
m_calendarPanel = new CalendarPanel();
contentPane.add(m_calendarPanel);
setResizable(false);
pack();
}
/**
* Sets the date for this calendar
* @param date date object. May be <Code>null</code>.
*/
public void setDate(Date date)
{
if(null == date)
return;
m_calendarPanel.setCalendarDate(date);
m_calendarPanel.loadCalendar();
}
/**
* Sets the date for this calendar
* @param year the year integer ( i.e. 2003)
* @param month the month integer ( 0 - 11; Example: February = 2)
* @param date the date integer (1 - 31)
*/
public void setDate(int year, int month, int date)
{
m_calendarPanel.setCalendarDate(
new GregorianCalendar(year, month, date).getTime());
m_calendarPanel.loadCalendar();
}
/**
* Returns the date that the Calendar dialog
* is currently set to.
* @return the date. Never <code>null</code>.
*/
public Date getDate()
{
return m_calendarPanel.getCalendar().getTime();
}
/**
* Centers the dialog on the screen, based on its current size.
*/
public void center()
{
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension size = getSize();
setLocation(( screenSize.width - size.width ) / 2,
( screenSize.height - size.height ) / 2 );
}
/**
* Indicates that date was actually selected
* @return <code>true</code> if date was selected, else
* <code>false</code>.
*/
public boolean isDateSelected()
{
return m_bDateSelected;
}
/**
* Sets the foreground color of the calendar grid
* @param color. Never <code>null</code>.
*/
public void setGridForeground(Color color)
{
if(null == color)
return;
m_calendarPanel.setGridForeground(color);
}
/**
* Sets the background color of the calendar grid
* @param color. Never <code>null</code>.
*/
public void setGridBackground(Color color)
{
if(null == color)
return;
m_calendarPanel.setGridBackground(color);
}
/**
* Sets the foreground color of the calendar header
* @param color. Never <code>null</code>.
*/
public void setHeaderForeground(Color color)
{
if(null == color)
return;
m_calendarPanel.setHeaderForeground(color);
}
/**
* Sets the background color of the calendar header
* @param color. Never <code>null</code>.
*/
public void setHeaderBackground(Color color)
{
if(null == color)
return;
m_calendarPanel.setHeaderBackground(color);
}
/**
* Sets the current date foreground color.
* @param color. Never <code>null</code>.
*/
public void setCurrentDateForeground(Color color)
{
if(null == color)
return;
m_calendarPanel.m_gridCurrentForeground = color;
}
/**
* Sets the mouseover border color
* @param color. Never <code>null</code>.
*/
public void setMouseOverBorderColor(Color color)
{
if(null == color)
return;
m_calendarPanel.m_mouseOverBorderColor = color;
}
/**
* Sets the mouse over background color
* @param color. Never <code>null</code>.
*/
public void setMouseOverBackground(Color color)
{
if(null == color)
return;
m_calendarPanel.m_mouseOverBackground = color;
}
/**
* Set the year selection popup offset.
* @param offset the number previous and next years
* to display in the year selection popup. Defaults to 3
*/
public void setYearPopupOffset(int offset)
{
m_yearPopupOffset = offset;
}
/**
* Panel that represents the calendar grid
*/
class CalendarPanel extends JPanel
{
/**
* Construct a new calendar panel
*/
CalendarPanel()
{
super();
init();
loadCalendar();
}
/**
* Initialize the gui components, build the calendar grid
*/
public void init()
{
CalendarActionListener actionListener = new CalendarActionListener();
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
JPanel panel = new JPanel(new BorderLayout());
Dimension calSize = new Dimension(340, 160);
panel.setPreferredSize(calSize);
panel.setMaximumSize(calSize);
panel.setBorder(BorderFactory.createEtchedBorder());
JLabel label = null;
m_grid = new ArrayList(35);
m_header = new ArrayList(7);
// Build calendar header
JPanel headerpanel = new JPanel(new GridLayout(1, 7, 2, 2));
for(int i = 0; i < ms_headerText.length; i++)
{
label = new JLabel(ms_headerText[i]);
m_header.add(label);
label.setBackground(m_headerBackground);
label.setForeground(m_headerForeground);
label.setHorizontalAlignment(JLabel.CENTER);
label.setOpaque(true);
headerpanel.add(label);
}
panel.add(headerpanel, BorderLayout.NORTH);
// Build calendar grid
JPanel gridpanel = new JPanel(new GridLayout(6, 7, 2, 2));
for(int i = 0; i < 42; i++)
{
CalendarDayButton button = new CalendarDayButton(JButton.CENTER, JButton.CENTER, true);
button.addActionListener(actionListener);
m_grid.add(button);
gridpanel.add(button);
}
panel.add(gridpanel, BorderLayout.CENTER);
// Build control panel
JPanel controlPanel = new JPanel();
controlPanel.setLayout(new BoxLayout(controlPanel, BoxLayout.X_AXIS));
ImageIcon arrowL = new ImageIcon(getClass().getResource(ms_res.getString("gif.left.arrow")));
ImageIcon arrowR = new ImageIcon(getClass().getResource(ms_res.getString("gif.right.arrow")));
m_prevButton = new JButton(arrowL);
m_prevButton.addActionListener(actionListener);
m_prevButton.setToolTipText(ms_res.getString("tooltip.prev.month"));
m_nextButton = new JButton(arrowR);
m_nextButton.addActionListener(actionListener);
m_nextButton.setToolTipText(ms_res.getString("tooltip.next.month"));
// load the drop down menu for the months
m_monthList = null;
loadMonthList();
m_monthList.addActionListener(actionListener);
// load the drop down menu for the year
m_yearList = null;
loadYearList();
m_yearList.addActionListener(actionListener);
controlPanel.add(m_prevButton);
controlPanel.add(Box.createHorizontalGlue());
controlPanel.add(m_monthList);
controlPanel.add(Box.createHorizontalStrut(10));
controlPanel.add(m_yearList);
controlPanel.add(Box.createHorizontalGlue());
controlPanel.add(m_nextButton);
controlPanel.setFocusable(true);
add(Box.createVerticalStrut(5));
add(controlPanel);
add(Box.createVerticalStrut(5));
add(panel);
add(Box.createVerticalStrut(10));
}
/**
* Add the items in the years combo box. It initializes m_yearList, so
* it is never <code>null</code> after this method.
*
*/
private void loadYearList()
{
ActionListener listener = null;
if (m_yearList == null)
{
m_yearList = new JComboBox();
}
else
{
// remove the action listener so the fired event
// because of the modification of the elements
listener = m_yearList.getActionListeners()[0];
m_yearList.removeActionListener(listener);
m_yearList.removeAllItems();
}
// set uneditable because the user should not be able to type on it
m_yearList.setEditable(false);
// fill the drop down list
int year = m_currCalendar.get(Calendar.YEAR);
for (int i = (year - m_yearPopupOffset), j = 0; i < (year + m_yearPopupOffset + 1); i++, j++)
{
m_yearList.addItem(String.valueOf(i));
if (String.valueOf(m_currCalendar.get(Calendar.YEAR)).equals(String.valueOf(i)))
{
m_yearList.setSelectedIndex(j);
}
}
// add the listener again
m_yearList.addActionListener(listener);
}
/**
* Add the items in the month combo box. It initializes m_monthList, so
* it is never <code>null</code> after this method.
*
*/
private void loadMonthList()
{
m_monthList = new JComboBox();
// set uneditable because the user should not be able to type on it
m_monthList.setEditable(false);
// fill the drop down list
for(int i = 0; i < ms_months.length; i++)
{
m_monthList.addItem(ms_months[i]);
}
// Select the right month
m_monthList.setSelectedIndex(m_calendar.get(Calendar.MONTH));
}
/**
* Changes the selection of the month list if the user hits on the
* previous month button or the next month button.
*/
private void reloadMonthList()
{
m_monthList.setSelectedIndex(m_currCalendar.get(Calendar.MONTH));
}
/**
* Returns reference to the <code>Calendar</code> object.
* @return Calendar object. Never <code>null</code>.
*/
public Calendar getCalendar()
{
return m_calendar;
}
/**
* Loads calendar to represent the month/year currently
* selected by the user.
*/
private void loadCalendar()
{
m_currCalendar.set(Calendar.DATE, 1);
int month = m_currCalendar.get(Calendar.MONTH);
int year = m_currCalendar.get(Calendar.YEAR);
int firstDay = m_currCalendar.get(Calendar.DAY_OF_WEEK);
int lastDay = m_currCalendar.getActualMaximum(Calendar.DAY_OF_MONTH);
Iterator it = m_grid.iterator();
int count = 0;
Date tempDate = decrementDate(m_currCalendar.getTime(), firstDay);
while(it.hasNext())
{
tempDate = incrementDate(tempDate, 1);
CalendarDayButton current = (CalendarDayButton) it.next();
// Set defaults
current.setForeground(m_gridForeground);
current.setCurrentSelection(false);
current.setCalendar(tempDate);
if(month != current.getCalendar().get(Calendar.MONTH))
{
// This date is not in the current month and
// should be grayed out
current.setForeground(new Color(127, 127, 127));
}
if(calendarDatesEqual(m_calendar, current.getCalendar()))
{
// If this is selected date then render
// selection circle
current.setCurrentSelection(true);
reloadMonthList();
loadYearList();
}
if(current.isToday())
{
// If this is today's date then change color
// to indicate it is today.
current.setForeground(m_gridCurrentForeground);
}
count++;
}
// set the Accessible information to the calendar. The accessible
// name will be like this:
// Calendar Dialog, September, 2011
AccessibleContext aCtx = getAccessibleContext();
if (aCtx != null)
{
aCtx.setAccessibleName("Calendar Dialog, " + ms_months[m_currCalendar.get(Calendar.MONTH)] + ", "
+ m_currCalendar.get(Calendar.YEAR));
}
setToolTipText("Calendar Dialog, " + ms_months[m_currCalendar.get(Calendar.MONTH)] + ", "
+ m_currCalendar.get(Calendar.YEAR));
}
/**
* Increment the date by the number of days passed in
* @param date the date to be incremented. May not be
* <code>null</code>.
* @param num number of days to increment the date by.
* @return a new date instance with the adjusted date. Never
* <code>null</code>.
*/
private Date incrementDate(Date date, int num)
{
if(null == date)
throw new IllegalArgumentException("Date cannot be null");
return new Date(date.getTime() + (ONE_DAY * (long)num));
}
/**
* Decrement the date by the number of days passed in
* @param date the date to be decremented. May not be
* <code>null</code>.
* @param num number of days to decrement the date by.
* @return a new date instance with the adjusted date. Never
* <code>null</code>.
*/
private Date decrementDate(Date date, int num)
{
if(null == date)
throw new IllegalArgumentException("Date cannot be null");
return new Date(date.getTime() - (ONE_DAY * (long)num));
}
/**
* Compares two calendars for date equality.
* @param calA calendar to check, May be <code>null</code>.
* @param calB calendar to check, May be <code>null</code>.
* @return <code>true</code> if both calendars are set to
* eqivilent dates, else <code>false</code>.
*/
private boolean calendarDatesEqual(Calendar calA, Calendar calB)
{
if(null == calA || null == calB)
return false;
return (calA.get(Calendar.YEAR) == calB.get(Calendar.YEAR) &&
calA.get(Calendar.MONTH) == calB.get(Calendar.MONTH) &&
calA.get(Calendar.DATE) == calB.get(Calendar.DATE));
}
/**
* Decrement calendar by one month
*/
private void previousMonth()
{
int month = m_currCalendar.get(Calendar.MONTH);
int year = m_currCalendar.get(Calendar.YEAR);
if(month < 1)
{
month = 11;
--year;
}
else
{
--month;
}
m_currCalendar.set(Calendar.MONTH, month);
m_currCalendar.set(Calendar.YEAR, year);
// reload the lists
reloadMonthList();
loadYearList();
loadCalendar();
}
/**
* Increment calendar by one month
*/
private void nextMonth()
{
int month = m_currCalendar.get(Calendar.MONTH);
int year = m_currCalendar.get(Calendar.YEAR);
if(month > 10)
{
month = 0;
++year;
}
else
{
++month;
}
m_currCalendar.set(Calendar.MONTH, month);
m_currCalendar.set(Calendar.YEAR, year);
// reload the lists
reloadMonthList();
loadYearList();
loadCalendar();
}
/**
* Set calendar dates for this panel
* @param date
*/
private void setCalendarDate(Date date)
{
m_calendar.setTime(date);
m_currCalendar.setTime(date);
}
/**
* Sets the background color of the calendar header
* @param color. Never <code>null</code>.
*/
private void setHeaderBackground(Color color)
{
if(null == color)
return;
m_headerBackground = color;
if(null != m_header)
{
Iterator it = m_header.iterator();
while(it.hasNext())
((JLabel)it.next()).setBackground(color);
}
}
/**
* Sets the foreground color of the calendar header
* @param color. Never <code>null</code>.
*/
private void setHeaderForeground(Color color)
{
if(null == color)
return;
m_headerForeground = color;
if(null != m_header)
{
Iterator it = m_header.iterator();
while(it.hasNext())
((JLabel)it.next()).setForeground(color);
}
}
/**
* Sets the background color of the calendar grid
* @param color. Never <code>null</code>.
*/
private void setGridBackground(Color color)
{
if(null == color)
return;
m_gridBackground = color;
if(null != m_header)
{
Iterator it = m_grid.iterator();
while(it.hasNext())
((JLabel)it.next()).setBackground(color);
}
}
/**
* Sets the foreground color of the calendar grid
* @param color. Never <code>null</code>.
*/
private void setGridForeground(Color color)
{
if(null == color)
return;
m_gridForeground = color;
if(null != m_header)
{
Iterator it = m_grid.iterator();
while(it.hasNext())
((JLabel)it.next()).setForeground(color);
}
}
/**
* Action listener class to handle the action performed for all of the
* controls presents in the Calendar. These controls are the previous and
* next month, the one to pick up the month and year and each of the days
* in the calendar.
*
* @author Santiago M. Murchio
*
*/
private class CalendarActionListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
Object source = event.getSource();
if (source == m_monthList)
{
// reload the calendar with the selected month
int data = ((JComboBox) source).getSelectedIndex();
m_currCalendar.set(Calendar.MONTH, data);
loadCalendar();
}
else if (source == m_yearList)
{
// reload the calendar with the selected year
Object dataString = ((JComboBox) source).getSelectedItem();
if (dataString != null)
{
int data = Integer.valueOf(((String) dataString).toString());
m_currCalendar.set(Calendar.YEAR, data);
loadCalendar();
}
}
else if (source == m_prevButton)
{
previousMonth();
}
else if (source == m_nextButton)
{
nextMonth();
}
else
{
CalendarDayButton dayButton = (CalendarDayButton) event.getSource();
// Date is considered selected if it has a non null
// value and the user clicks on it.
if (null != dayButton.getText())
{
m_calendar.setTime(dayButton.getCalendar().getTime());
m_bDateSelected = true;
dispose();
}
}
}
}
/**
* This class is the one we will use in the calendar for holding the
* days. This way the user will be able to navigate through the dialog
* with the keyboard using the TAB key. Introduced for bug RX-17051.
*
* @author Santiago M. Murchio
*
*/
private class CalendarDayButton extends JButton
{
/**
* The <code>Calendar</code> object for this label. Defaults to the
* current date/time.
*/
private Calendar m_cal = new GregorianCalendar();
/**
* Flag indicating that this date is the current selected date.
*/
private boolean m_isCurrentSelection;
public CalendarDayButton()
{
super();
}
/**
* Constructor that builds a default calendar button and then uses
* the parameters to set its horizontal alignment, its vertical
* alignment and the opaque.
*/
public CalendarDayButton(int horizontalAlignment, int verticalAlignment, boolean opaque)
{
super();
setBackground(m_gridBackground);
setForeground(m_gridForeground);
setHorizontalAlignment(horizontalAlignment);
setVerticalAlignment(verticalAlignment);
setOpaque(opaque);
}
public CalendarDayButton(String value)
{
super(value);
}
/**
* Construct a new CalendarLabel object setting it to the date in
* the Calendar passed in.
*
* @param calendar. May not be <code>null</code>.
*/
public CalendarDayButton(Calendar calendar)
{
this();
setCalendar(calendar);
}
/**
* Construct a new <code>CalendarLabel</code> object setting it to
* the date passed in.
*
* @param year year as integer
* @param month month as integer (0 - 11)
* @param date the date integer (1 - 31)
*/
public CalendarDayButton(int year, int month, int date)
{
this();
setCalendar(year, month, date);
}
/**
* Returns the date for this label
*
* @return the date. Never <code>null</code>.
*/
public Date getDate()
{
return m_cal.getTime();
}
/**
* Returns a reference to the <code>Calendar</code> object for this
* label.
*
* @return the calendar object. Never <code>null</code>.
*/
public Calendar getCalendar()
{
return m_cal;
}
/**
* Sets the current selection flag
*
* @param bool if <code>true</code> then a rectangle will be drawn
* around the date integer.
*/
public void setCurrentSelection(boolean bool)
{
m_isCurrentSelection = bool;
}
/**
* Indicates if the selection indicator should be drawn
*
* @return if <code>true</code> then a rectangle will be drawn
* around the date integer.
*/
public boolean isCurrentSelection()
{
return m_isCurrentSelection;
}
/**
* Set the calendar to the same date as the calendar passed in.
*
* @param calendar. May not be <code>null</code>.
*/
public void setCalendar(Calendar calendar)
{
m_cal.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
m_cal.set(Calendar.MONTH, calendar.get(Calendar.MONTH));
m_cal.set(Calendar.DATE, calendar.get(Calendar.DATE));
setText(String.valueOf(calendar.get(Calendar.DATE)));
setToolTipText(ms_months[m_cal.get(Calendar.MONTH)] + ", "
+ String.valueOf(m_cal.get(Calendar.DAY_OF_MONTH)));
setAccesibleInfo();
}
/**
* Set the calendar to the same date as the integer values passed
* in.
*
* @param year year as integer
* @param month month as integer (0 - 11)
* @param date the date integer (1 - 31)
*/
public void setCalendar(int year, int month, int date)
{
m_cal.set(Calendar.YEAR, year);
m_cal.set(Calendar.MONTH, month);
m_cal.set(Calendar.DATE, date);
setText(String.valueOf(date));
setToolTipText(ms_months[m_cal.get(Calendar.MONTH)] + ", "
+ String.valueOf(m_cal.get(Calendar.DAY_OF_MONTH)));
setAccesibleInfo();
}
/**
* Set the calendar to the date passed in
*
* @param date. May not be <code>null</code>.
*/
public void setCalendar(Date date)
{
m_cal.setTime(date);
setText(String.valueOf(m_cal.get(Calendar.DAY_OF_MONTH)));
setToolTipText(ms_months[m_cal.get(Calendar.MONTH)] + ", "
+ String.valueOf(m_cal.get(Calendar.DAY_OF_MONTH)));
setAccesibleInfo();
}
/**
* Gets the accessible context of the element and if it is not null,
* it sets the toolTip text as the accessible name. This way, screen
* readers can see the difference between two buttons that have the
* same number, but belong to different months.
*/
private void setAccesibleInfo()
{
AccessibleContext aCtx = getAccessibleContext();
if (aCtx != null)
{
aCtx.setAccessibleName(getToolTipText());
}
}
/**
* Is this calendar's date today's date
*
* @return <code>true</code> if this is today, else
* <code>false</code>.
*/
public boolean isToday()
{
Calendar c = new GregorianCalendar();
return (m_cal.get(Calendar.YEAR) == c.get(Calendar.YEAR)
&& m_cal.get(Calendar.MONTH) == c.get(Calendar.MONTH) && m_cal.get(Calendar.DATE) == c
.get(Calendar.DATE));
}
/**
* Override the <code>paintComponent</code> method so we can draw
* the selection indicator if needed.
*
* @param g graphics object. Never <code>null</code>.
*/
public void paintComponent(Graphics g)
{
super.paintComponent(g);
Dimension size = getSize();
if(isCurrentSelection())
{
g.setColor(Color.blue);
g.drawRect(2, 2, size.width-5, size.height-5);
}
if(isToday())
{
g.setColor(Color.black);
g.drawLine(5, 16, size.width - 6, 16);
}
}
}
/**
* List of label references to the calendar grid. Initialized in the ctor,
* Never <code>null</code> after that.
*/
private List m_grid;
/**
* List of label references to the calendar header. Initialized in the ctor,
* Never <code>null</code> after that.
*/
private List m_header;
/**
* Previous month button. Initalized in {@link init()}, Never
* <code>null</code> after that.
*/
private JButton m_prevButton;
/**
* Next month button. Initalized in {@link init()}, Never
* <code>null</code> after that.
*/
private JButton m_nextButton;
/**
* Popup menu for month selection. Initalized in {@link init()}, Never
* <code>null</code> after that.
*/
private JComboBox m_monthList;
/**
* Popup menu for year selection. Initalized in {@link init()}, Never
* <code>null</code> after that.
*/
private JComboBox m_yearList;
/**
* The calendar to represent the date for the current displayed
* calendar. Never <code>null</code>. Defaults to the current date/time.
*/
private GregorianCalendar m_currCalendar = new GregorianCalendar();
/**
* The calendar to represent the date passed in. Never <code>null</code>.
* Defaults to the current date/time.
*/
private GregorianCalendar m_calendar = new GregorianCalendar();
/**
* The header background color. Defaults to blue.
*/
private Color m_headerBackground = new Color(0, 51, 153);
/**
* The header foreground color. Defaults to white.
*/
private Color m_headerForeground = Color.white;
/**
* The grid background color. Defaults to white.
*/
private Color m_gridBackground = Color.white;
/**
* The grid foreground color. Defaults to black.
*/
private Color m_gridForeground = Color.black;
/**
* The grid current date foreground color. Defaults to
* red
*/
private Color m_gridCurrentForeground = Color.red;
/**
* The mouse over border color. Defaults to
* black
*/
private Color m_mouseOverBorderColor = Color.black;
/**
* The mouse over background color. Defaults to
* white
*/
private Color m_mouseOverBackground = Color.white;
}
/**
* Calendar panel to display the calendar grid. Initialized in
* the ctor. Never <code>null</code> after that.
*/
private CalendarPanel m_calendarPanel;
/**
* Flag indicating that a date was selected
*/
private boolean m_bDateSelected;
/**
* Year selection popup offset
*/
private int m_yearPopupOffset = 3;
/**
* Resource bundle reference. Never <code>null</code> after that.
*/
private static ResourceBundle ms_res;
static
{
try
{
ms_res = ResourceHelper.getResources();
}
catch(MissingResourceException ex)
{
System.out.println(ex);
throw ex;
}
}
/**
* MenuAction data key
*/
private static final String DATA = "DATA";
/**
* Month menu type
*/
private static final int MONTH_TYPE = 1;
/**
* Year menu type
*/
private static final int YEAR_TYPE = 2;
/**
* Seconds in one day
*/
private static final long ONE_DAY = 86400000L;
/**
* The calendar header array
*/
private static final String[] ms_headerText =
{
ms_res.getString("day.abbr.sun"),
ms_res.getString("day.abbr.mon"),
ms_res.getString("day.abbr.tues"),
ms_res.getString("day.abbr.wed"),
ms_res.getString("day.abbr.thur"),
ms_res.getString("day.abbr.fri"),
ms_res.getString("day.abbr.sat")
};
/**
* The month name array
*/
private static final String[] ms_months =
{
ms_res.getString("month.jan"),
ms_res.getString("month.feb"),
ms_res.getString("month.mar"),
ms_res.getString("month.apr"),
ms_res.getString("month.may"),
ms_res.getString("month.june"),
ms_res.getString("month.jul"),
ms_res.getString("month.aug"),
ms_res.getString("month.sep"),
ms_res.getString("month.oct"),
ms_res.getString("month.nov"),
ms_res.getString("month.dec")
};
/**
* Calendar representing Today's date
*/
private static Calendar ms_today = new GregorianCalendar();
}
| [
"[email protected]"
] | |
2cabb55d0fa511e77878581c7468d2f027701fa1 | f297be68825c1cc214868cb6f12bf2e0219a7122 | /src/org/jetume/nestedinterval/JpaEntity.java | c874408b6fd1ebb9516fca3107d43b1e55a2cf47 | [] | no_license | jetume/JPA-NestedInterval | 47905217051c1b4a1af34f89475c1ec3e5258601 | 5ebfb5b3689f2766ba6f6b9efcfc960599cc369f | refs/heads/master | 2021-01-13T01:40:11.852361 | 2012-06-11T18:39:36 | 2012-06-11T18:39:36 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,496 | java | package org.jetume.nestedinterval;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class JpaEntity {
@Id
@GeneratedValue
private int id;
@Column(updatable = false)
private int a11;
@Column(updatable = false)
private int a12;
@Column(updatable = false)
private int a21;
@Column(updatable = false)
private int a22;
@Column(updatable = false)
private int childnum;
private String rootid;
private String name;
public int getId() {
return id;
}
public int getA11() {
return a11;
}
public void setA11(int a11) {
this.a11 = a11;
}
public int getA12() {
return a12;
}
public void setA12(int a12) {
this.a12 = a12;
}
public int getA21() {
return a21;
}
public void setA21(int a21) {
this.a21 = a21;
}
public int getA22() {
return a22;
}
public void setA22(int a22) {
this.a22 = a22;
}
public int getChildnum() {
return childnum;
}
public void setChildnum(int childnum) {
this.childnum = childnum;
}
public String getRootid() {
return rootid;
}
public void setRootid(String rootid) {
this.rootid = rootid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "JpaEntity [id=" + id + ", a11=" + a11 + ", a12=" + a12
+ ", a21=" + a21 + ", a22=" + a22 + ", childnum=" + childnum
+ ", name=" + name + "]";
}
}
| [
"[email protected]"
] | |
b47a0c56515f22f205ad4aa990213670bd251fb9 | 800fbf2c2b883f76110a023b308ac1ad7f5f6949 | /src/com/practice/java/datastructure/algorithms/Fibonacci.java | 55e6b1db85b1b2036be7644edb45ec1364280b52 | [] | no_license | sameer118/practice-java | 0244dcb1faf6b76a3bf7cb78e5cdd906c36dc84e | 5d1f51eba9576538812e92297ab0aba6c2a54a4c | refs/heads/master | 2021-06-18T00:05:18.403067 | 2017-06-12T05:52:47 | 2017-06-12T05:52:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 423 | java | package com.practice.java.datastructure.algorithms;
class Fibonacci {
public int generate(int pos) {
int sum = 0, x = 0, y = 0;
for (int i = 1; i < pos; i++) {
sum = sum + x + i;
}
return sum;
}
public static void main(String args[]) {
int prev, next, sum, n;
prev = next = 1;
for (n = 1; n <= 10; n++) {
System.out.println(prev);
sum = prev + next;
prev = next;
// next = sum;
}
}
}
| [
"[email protected]"
] | |
37f8036e40c490349515b13b949574fbf40dd173 | 3c63907025075a4eb5554b3cb4a2bbcce6d04cc9 | /itsnat_dev/src/main/java/test/web/core/treecustom/SecondLevelTreeStructure.java | 31d46707f53062ecd802edfd368aef4a7de78f7a | [] | no_license | jmarranz/itsnat_server | 36da4d7c2c91c7d07c4a6c639b6513f16def639d | 49337e09adda04ad120eecf9eea614ac4e44c8ab | refs/heads/master | 2020-04-10T15:52:49.481387 | 2016-04-13T18:04:28 | 2016-04-13T18:04:28 | 6,872,297 | 5 | 3 | null | null | null | null | UTF-8 | Java | false | false | 1,296 | java | /*
* FirstLevelTreeStructure.java
*
* Created on 22 de agosto de 2007, 14:35
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
package test.web.core.treecustom;
import org.itsnat.core.domutil.ElementTreeNode;
import org.itsnat.core.domutil.ElementTreeNodeStructure;
import org.w3c.dom.Element;
/**
*
* @author jmarranz
*/
public class SecondLevelTreeStructure implements ElementTreeNodeStructure
{
public static final SecondLevelTreeStructure SINGLETON = new SecondLevelTreeStructure();
/** Creates a new instance of FirstLevelTreeStructure */
public SecondLevelTreeStructure()
{
}
public Element getContentElement(ElementTreeNode treeNode,Element nodeElem)
{
return null;
}
public Element getHandleElement(ElementTreeNode treeNode,Element nodeElem)
{
return null;
}
public Element getIconElement(ElementTreeNode treeNode,Element nodeElem)
{
return null;
}
public Element getLabelElement(ElementTreeNode treeNode,Element nodeElem)
{
return nodeElem;
}
public Element getChildListElement(ElementTreeNode treeNode,Element nodeElem)
{
return null;
}
}
| [
"[email protected]"
] | |
e927d0602129f3d0b9aab10af5512b6bfc75ebda | 549484d1e0186ef0f5b6e3472f67604a0335de60 | /src/main/java/lt/vu/services/FastMyBatisBrawl.java | b96308835ba84e1f8bf8e945db100282cc385b40 | [] | no_license | mr-frying-pan/PSK_Lab | dbd5fbd95b292ed80d50390abb2524dd0d8f383b | 7e5ad0c578a93ae1927901b10e6c5d900b77c452 | refs/heads/master | 2023-04-07T15:31:23.986665 | 2020-05-19T13:04:12 | 2020-05-19T13:04:12 | 255,445,420 | 0 | 0 | null | 2021-04-22T19:04:39 | 2020-04-13T21:28:23 | Java | UTF-8 | Java | false | false | 646 | java | package lt.vu.services;
import lt.vu.interceptors.Log;
import lt.vu.mybatis.model.Fighter;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Alternative;
import javax.inject.Inject;
import java.util.List;
@ApplicationScoped
@Alternative
public class FastMyBatisBrawl implements TavernBrawl {
@Inject
private MagicAction magicAction;
@Log
@Override
public List<Fighter> brawl(List<Fighter> fighters) {
System.out.println("SHORT BRAWL");
try {
Thread.sleep(magicAction.doIt());
} catch (InterruptedException e) {
}
return fighters;
}
}
| [
"[email protected]"
] | |
cf06624b6ed52d956ce339f3746bf50f0724c9cb | 1e22d0efddc07286d79cf1e162486bcbc6ea29c0 | /app/src/main/java/com/example/android/tourguideapp/PlaceDetailsActivity.java | b08654cd6672feb70cc6a92d7fc498d1ae56ac15 | [] | no_license | minervam/TourGuideApp | 0d017836479eabd3b149d9ae41dbd6b2d5e42ea5 | bc1cf82e1e25eda57a316db134d9ffdd7ed2285d | refs/heads/master | 2020-03-22T02:57:22.855756 | 2018-07-03T04:32:30 | 2018-07-03T04:32:30 | 139,403,535 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,847 | java | package com.example.android.tourguideapp;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ImageView;
import android.widget.TextView;
public class PlaceDetailsActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.section_details);
//Get the properties of the Place Object from the intent
Bundle b = getIntent().getExtras();
String placeName = b.getString(getString(R.string.name_var));
String placeAddress = b.getString(getString(R.string.address_var));
String placeDescription = b.getString(getString(R.string.desc_var));
int placeImage = b.getInt(getString(R.string.img_var));
//Set the name of the place as the title of the screen
this.setTitle(placeName);
//Activate Up Button to enable the navigation back to the MainActivity
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
//Set the image to the ImageView in the section_details
ImageView imageView = (ImageView) findViewById(R.id.detailed_image);
imageView.setImageResource(placeImage);
//Set the name to the TextView in the section_details.xmlils.xml
TextView nameTextView = (TextView) findViewById(R.id.detailed_name);
nameTextView.setText(placeName);
//Set the address to the TextView in the section_details
TextView addressTextView = (TextView) findViewById(R.id.detailed_address);
addressTextView.setText(placeAddress);
//Set the description to the TextView in the section_details
TextView descriptionTextView = (TextView) findViewById(R.id.detailed_desc);
descriptionTextView.setText(placeDescription);
}
}
| [
"[email protected]"
] | |
7ac9cd63916bb9aaec3006023f3214f859b105ac | 00cb6f98d9796ca777afc9d26cb557b6f5fe3cda | /mygo/mygo-alipay/src/main/java/com/alipay/api/domain/KbAdvertIdentifyResponse.java | f6a0e7cbfb75babd634b66f5b3dd219b7114745d | [] | no_license | caizhongao/mygo | e79a493948443e6bb17a4390d0b31033cd98d377 | 08a36fe0aced49fc46f4541af415d6e86d77d9c9 | refs/heads/master | 2020-09-06T12:45:37.350935 | 2017-06-26T05:51:50 | 2017-06-26T05:51:50 | 94,418,912 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,528 | java | package com.alipay.api.domain;
import java.util.List;
import com.alipay.api.AlipayObject;
import com.alipay.api.internal.mapping.ApiField;
import com.alipay.api.internal.mapping.ApiListField;
/**
* 口碑广告系统主键结果
*
* @author auto create
* @since 1.0, 2017-03-03 14:25:50
*/
public class KbAdvertIdentifyResponse extends AlipayObject {
private static final long serialVersionUID = 1325465512333867428L;
/**
* 根据benefit_type，确定ID含义
SINGLE_VOUCHER时，benefit_ids为券ID
*/
@ApiListField("benefit_ids")
@ApiField("string")
private List<String> benefitIds;
/**
* 发放权益类型
SINGLE_VOUCHER：单券
*/
@ApiField("benefit_type")
private String benefitType;
/**
* 返回码
success: 成功
invalid-arguments: 无效参数
retry-exception: 异常请重试
isv.user-already-get-voucher：用户已经领过该券，同时券状态为有效
isv.item_inventory_not_enough:优惠领光了
isv.item_not_in_this_shop_sales:不是该商家的优惠，不能领取
isv.voucher_activity_not_started:活动未开始
isv.voucher_activity_expired:活动已结束
isv.crowd_limit_not_match_error:暂无领取资格，详情请咨询商家
isv.member_crowd_limit_not_match_error:会员专属，请先注册会员
*/
@ApiField("code")
private String code;
/**
* JSON格式数据，需要ISV自行解析
*/
@ApiField("ext_info")
private String extInfo;
/**
* 主键的值
*/
@ApiField("identify")
private String identify;
/**
* 主键类型
*/
@ApiField("identify_type")
private String identifyType;
public List<String> getBenefitIds() {
return this.benefitIds;
}
public void setBenefitIds(List<String> benefitIds) {
this.benefitIds = benefitIds;
}
public String getBenefitType() {
return this.benefitType;
}
public void setBenefitType(String benefitType) {
this.benefitType = benefitType;
}
public String getCode() {
return this.code;
}
public void setCode(String code) {
this.code = code;
}
public String getExtInfo() {
return this.extInfo;
}
public void setExtInfo(String extInfo) {
this.extInfo = extInfo;
}
public String getIdentify() {
return this.identify;
}
public void setIdentify(String identify) {
this.identify = identify;
}
public String getIdentifyType() {
return this.identifyType;
}
public void setIdentifyType(String identifyType) {
this.identifyType = identifyType;
}
}
| [
"[email protected]"
] | |
79a072cb7791b32838e4d949952ca3d6838f5965 | b0b40790a9b5a1d81f8f82932da7d8f126edbe48 | /src/test/java/junit/ExecutionOrder.java | b4cb4ffd4a3b56d2ded988594fc273b2329fb483 | [] | no_license | ArekLopus/JUnitTest | d319da6e69d0b40ea4f6ade25a0d7edfe8b68817 | d9e1391336629c519f155171eb3f25c381d0adc6 | refs/heads/master | 2021-08-24T18:15:03.097415 | 2017-11-21T11:34:17 | 2017-11-21T11:34:17 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 488 | java | package junit;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
//@FixMethodOrder(MethodSorters.NAME_ASCENDING)
//@FixMethodOrder(MethodSorters.JVM)
@FixMethodOrder(MethodSorters.DEFAULT)
public class ExecutionOrder {
@Test
public void testA() {
System.out.println("first");
}
@Test
public void testB() {
System.out.println("second");
}
@Test
public void testC() {
System.out.println("third");
}
}
| [
"[email protected]"
] | |
d0fd948fa3833be53efeef6560eb56cc6263066d | 7abfcb23609759830401d07c1e6074891f7a07ca | /src/main/java/org/anc/io/LinePrinter.java | b82039a9fdf3184fd7909e59c7866a24db42db61 | [
"Apache-2.0"
] | permissive | oanc/org.anc.common | 1b287049778456d1c369fa8af07a0c9f4509f86f | e28b1f5902998a6e3e0c2942f666ebb7781c539d | refs/heads/master | 2021-01-11T08:09:35.845918 | 2016-09-28T22:52:10 | 2016-09-28T22:52:10 | 69,401,239 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,041 | java | /*-
* Copyright 2009 The American National Corpus
*
* 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.anc.io;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
*
* @author Keith Suderman
* @version 1.0
*/
public class LinePrinter
{
private ILinePrinter printer;
public LinePrinter(PrintWriter writer)
{
super();
printer = new WriterLinePrinter(writer);
}
public LinePrinter(PrintStream stream)
{
printer = new StreamLinePrinter(stream);
}
public void println()
{
printer.println();
}
public void println(Object object)
{
printer.println(object);
}
public void println(String s)
{
printer.println(s);
}
public void println(char[] ch)
{
printer.println(ch);
}
public void print(Object object)
{
printer.print(object);
}
public void print(String s)
{
printer.print(s);
}
public void print(char[] ch)
{
printer.print(ch);
}
public void print(char c)
{
printer.print(c);
}
public void close()
{
printer.close();
}
}
interface ILinePrinter
{
void println();
void println(Object object);
void println(String s);
void println(char[] ch);
void println(char c);
void print(Object object);
void print(String s);
void print(char[] ch);
void print(char c);
void close();
}
class StreamLinePrinter implements ILinePrinter
{
private PrintStream out;
public StreamLinePrinter(PrintStream stream)
{
out = stream;
}
@Override
public void println()
{
out.println();
}
@Override
public void println(Object object)
{
out.println(object);
}
@Override
public void println(String s)
{
out.println(s);
}
@Override
public void println(char[] ch)
{
out.println(ch);
}
@Override
public void println(char c)
{
out.println(c);
}
@Override
public void print(Object object)
{
out.print(object);
}
@Override
public void print(String s)
{
out.print(s);
}
@Override
public void print(char[] ch)
{
out.print(ch);
}
@Override
public void print(char c)
{
out.print(c);
}
@Override
public void close()
{
out.close();
}
}
class WriterLinePrinter implements ILinePrinter
{
private PrintWriter out;
public WriterLinePrinter(PrintWriter writer)
{
out = writer;
}
@Override
public void println()
{
out.println();
}
@Override
public void println(Object object)
{
out.println(object);
}
@Override
public void println(String s)
{
out.println(s);
}
@Override
public void println(char[] ch)
{
out.println(ch);
}
@Override
public void println(char c)
{
out.println(c);
}
@Override
public void print(Object object)
{
out.print(object);
}
@Override
public void print(String s)
{
out.print(s);
}
@Override
public void print(char[] ch)
{
out.print(ch);
}
@Override
public void print(char c)
{
out.print(c);
}
@Override
public void close()
{
out.close();
}
}
| [
"ksuderman@edd201f6-e76c-4490-bd89-b6241560e6fd"
] | ksuderman@edd201f6-e76c-4490-bd89-b6241560e6fd |
Subsets and Splits