hexsha stringlengths 40 40 | size int64 8 1.04M | content stringlengths 8 1.04M | avg_line_length float64 2.24 100 | max_line_length int64 4 1k | alphanum_fraction float64 0.25 0.97 |
|---|---|---|---|---|---|
79d94e8cac9a8fc5619a27134417a55d2c2c8b57 | 401 | package io.renren.modules.sys.dao;
import io.renren.modules.sys.entity.NideshopUserIntegralEntity;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* 用户积分表
*
* @author Mark
* @email sunlightcs@gmail.com
* @date 2020-07-04 19:31:22
*/
@Mapper
public interface NideshopUserIntegralDao extends BaseMapper<NideshopUserIntegralEntity> {
}
| 22.277778 | 89 | 0.780549 |
2b816f560f2766af68e86e0ffab76f7d5c56f49f | 2,659 | package com.grupa1.SopoProject.database;
import com.grupa1.SopoProject.handlers.UserAlreadyVotedException;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
/**
* @author Michal on 22.12.2018
*/
@Entity
@Table(name = "Project")
@Getter
@Setter
public class Project extends AuditItem{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(name = "projectName")
private String projectName;
@OneToOne
@JoinColumn(name = "userId")
private User user;
@Column(name = "budget")
private Double budget;
@ManyToOne
@JoinColumn(name = "neighbourhoodId")
private Neighbourhood neighbourhood;
@Column(name = "description", length = 2000)
private String description;
@Column(name = "address")
private String address;
@Column(name = "voteAmount")
private Long voteAmount;
@ManyToMany(cascade = {
CascadeType.PERSIST,
CascadeType.MERGE
})
@JoinTable(name = "projectComments",
joinColumns = @JoinColumn(name = "projectId"),
inverseJoinColumns = @JoinColumn(name = "commentId")
)
private List<ProjectComment> projectComments = new ArrayList<>();
@ManyToMany(cascade = {
CascadeType.PERSIST,
CascadeType.MERGE
})
@JoinTable(name = "projectVotingUser",
joinColumns = @JoinColumn(name = "projectId"),
inverseJoinColumns = @JoinColumn(name = "userId")
)
private List<User> projectVotingUser = new ArrayList<>();
public void addCommentToProject(ProjectComment projectComment){
this.projectComments.add(projectComment);
}
public Project() {
}
public Project(String projectName, User user, Double budget, Neighbourhood neighbourhood, String description, List<ProjectComment> projectComments, String address) {
this.projectName = projectName;
this.user = user;
this.budget = budget;
this.neighbourhood = neighbourhood;
this.description = description;
this.voteAmount = 0L;
this.projectComments = projectComments;
this.address = address;
}
public void vote(User user) throws UserAlreadyVotedException {
if(projectVotingUser == null){
this.projectVotingUser = new ArrayList<>();
}
if(projectVotingUser.contains(user)){
throw new UserAlreadyVotedException("User already voted for project: " + projectName);
}
voteAmount++;
projectVotingUser.add(user);
}
}
| 27.412371 | 169 | 0.658518 |
674b3a15b49cd7517470342354579c7e7db46ceb | 1,059 | package ua.com.fielden.platform.sample.domain;
import com.google.inject.Inject;
import ua.com.fielden.platform.dao.CommonEntityDao;
import ua.com.fielden.platform.entity.annotation.EntityType;
import ua.com.fielden.platform.entity.fetch.IFetchProvider;
import ua.com.fielden.platform.entity.query.IFilter;
/**
* DAO implementation for companion object {@link ITgCentreInvokerWithCentreContext}.
*
* @author Developers
*
*/
@EntityType(TgCentreInvokerWithCentreContext.class)
public class TgCentreInvokerWithCentreContextDao extends CommonEntityDao<TgCentreInvokerWithCentreContext> implements ITgCentreInvokerWithCentreContext {
@Inject
public TgCentreInvokerWithCentreContextDao(final IFilter filter) {
super(filter);
}
@Override
public IFetchProvider<TgCentreInvokerWithCentreContext> createFetchProvider() {
return super.createFetchProvider()
.with("key") // this property is "required" (necessary during saving) -- should be declared as fetching property
.with("desc");
}
} | 35.3 | 153 | 0.766761 |
044caf9abfa163c73745a7523227733bb17b8c8b | 2,567 | package com.afirme.payment.example.rest.model;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
public class Transaction {
@SerializedName("status")
@Expose
private String status;
@SerializedName("payment_date")
@Expose
private String paymentDate;
@SerializedName("amount")
@Expose
private Double amount;
@SerializedName("authorization_code")
@Expose
private String authorizationCode;
@SerializedName("installments")
@Expose
private Integer installments;
@SerializedName("dev_reference")
@Expose
private String devReference;
@SerializedName("message")
@Expose
private String message;
@SerializedName("error_code")
@Expose
private String errorCode;
@SerializedName("id")
@Expose
private String id;
@SerializedName("status_detail")
@Expose
private Integer statusDetail;
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getPaymentDate() {
return paymentDate;
}
public void setPaymentDate(String paymentDate) {
this.paymentDate = paymentDate;
}
public Double getAmount() {
return amount;
}
public void setAmount(Double amount) {
this.amount = amount;
}
public String getAuthorizationCode() {
return authorizationCode;
}
public void setAuthorizationCode(String authorizationCode) {
this.authorizationCode = authorizationCode;
}
public Integer getInstallments() {
return installments;
}
public void setInstallments(Integer installments) {
this.installments = installments;
}
public String getDevReference() {
return devReference;
}
public void setDevReference(String devReference) {
this.devReference = devReference;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Integer getStatusDetail() {
return statusDetail;
}
public void setStatusDetail(Integer statusDetail) {
this.statusDetail = statusDetail;
}
}
| 21.391667 | 64 | 0.652123 |
fde715044547c026527e9e0102157b8bdd7c5af1 | 5,699 | package models;
import org.sql2o.Connection;
import java.util.List;
public class EndangeredAnimal implements AnimalInterface {
//Declaring our variables
public String name;
public int id;
public boolean endangered;
private int health;
private int age;
//Declaring our constants.
public static final int MIN_HEALTH_LEVEL = 1;
public static final int HEALTHY = 8;
public static final int ILL = 12;
public static final int OKAY = 0;
public static final int NEW_BORN = 3;
public static final int YOUNG = 8;
public static final int ADULT = 12;
//Constructor class.
public EndangeredAnimal(String name, int health, int age) {
this.name = name;
this.id = id;
this.health = health;
this.age = age;
}
public void extinct(){
if (health <= MIN_HEALTH_LEVEL){
throw new UnsupportedOperationException("Your animal may go extinct! You need to feed it");
}
health++;
}
//getter method for the health variable
public int getHealth() {
return health;
}
//getter method for the age variable.
public int getAge() {
return age;
}
//getter method fo the name variable
public String getName() {
return name;
}
//getter method for the ID variable.
public int getId() {
return id;
}
//overridden update name method.
@Override
public void updateName(String name) {
try(Connection con = DB.sql2o.open()) {
String sql = "UPDATE endangered_animals SET name=:name WHERE id=:id;";
con.createQuery(sql)
.addParameter("id", id)
.addParameter("name", name)
.executeUpdate();
}
}
//overridden written equal method that compares the instances of this class objects.
@Override
public boolean equals(Object otherEndangeredAnimal) {
if(!(otherEndangeredAnimal instanceof EndangeredAnimal)) {
return false;
} else {
EndangeredAnimal newEndangeredAnimal = (EndangeredAnimal) otherEndangeredAnimal;
return this.getName().equals(newEndangeredAnimal.getName());
}
}
//Save method that inputs the data into the database.
public void save() {
try(Connection con = DB.sql2o.open()) {
String sql = "INSERT INTO endangered_animals (name, health, age) VALUES (:name, :health, :age);";
this.id = (int) con.createQuery(sql, true)
.addParameter("name", this.name)
.addParameter("health", this.health)
.addParameter("age", this.age)
.executeUpdate()
.getKey();
}
}
//static method that lists all instances of this class.
public static List<EndangeredAnimal> all() {
try(Connection con = DB.sql2o.open()) {
String sql = "SELECT * FROM endangered_animals;";
return con.createQuery(sql)
.executeAndFetch(EndangeredAnimal.class);
}
}
//Static method that gets all database entries with this class instance ID.
public static List<Sighting> allEndangeredAnimalSighting(int id) {
try(Connection con = DB.sql2o.open()) {
String sql = "SELECT * FROM sightings WHERE animal_id=:id ;";
List<Sighting> sightings = con.createQuery(sql)
.addParameter("id", id)
.executeAndFetch(Sighting.class);
return sightings;
}
}
//static methods that finds a database entry based on a specific ID
public static EndangeredAnimal find(int id) {
try(Connection con = DB.sql2o.open()) {
String sql = "SELECT * FROM endangered_animals WHERE id=:id;";
EndangeredAnimal endangeredanimal = con.createQuery(sql)
.addParameter("id", id)
.executeAndFetchFirst(EndangeredAnimal.class);
return endangeredanimal;
}
}
///Public method that utilizes the constant to check if instance is dead or alive.
public void updateHealth(int health) {
extinct();
try(Connection con = DB.sql2o.open()) {
String sql = "UPDATE endangered_animals SET health=:health WHERE id=:id;";
con.createQuery(sql)
.addParameter("id", id)
.addParameter("health", health)
.executeUpdate();
}
}
//Method that updates the age of the animal instance
public void updateAge(int age) {
try(Connection con = DB.sql2o.open()) {
String sql = "UPDATE endangered_animals SET age=:age WHERE id=:id;";
con.createQuery(sql)
.addParameter("age", age)
.addParameter("id", id)
.executeUpdate();
}
}
//Method that gets all instances of the database entries where the animal ID exists.
public List<Sighting> getSightings() {
try(Connection con = DB.sql2o.open()) {
String sql = "SELECT * FROM sightings WHERE animal_id=:id;";
List<Sighting> sightings = con.createQuery(sql)
.addParameter("id", id)
.executeAndFetch(Sighting.class);
return sightings;
}
}
public void delete() {
try(Connection con = DB.sql2o.open()) {
String sql = "DELETE FROM endangered_animals WHERE id=:id;";
con.createQuery(sql)
.addParameter("id", id)
.executeUpdate();
}
}
}
| 33.327485 | 109 | 0.582207 |
d82483832770a8ac91c301eae59aea5c30c328ef | 4,998 | /* LanguageTool, a natural language style checker
* Copyright (C) 2009 Daniel Naber (http://www.danielnaber.de)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
* USA
*/
package org.languagetool.language;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.languagetool.*;
import org.languagetool.languagemodel.LanguageModel;
import org.languagetool.rules.*;
import org.languagetool.rules.ga.*;
import org.languagetool.synthesis.Synthesizer;
import org.languagetool.synthesis.ga.IrishSynthesizer;
import org.languagetool.tagging.Tagger;
import org.languagetool.tagging.disambiguation.Disambiguator;
import org.languagetool.tagging.disambiguation.ga.IrishHybridDisambiguator;
import org.languagetool.tagging.ga.IrishTagger;
import org.languagetool.tokenizers.*;
import java.io.File;
import java.io.IOException;
import java.util.*;
/**
* @since 4.9
*/
public class Irish extends Language implements AutoCloseable {
private static final Language DEFAULT_IRISH = new Irish();
private LanguageModel languageModel;
@Override
public String getName() {
return "Irish";
}
@Override
public String[] getCountries() {
return new String[]{"IE"};
}
@Override
public String getShortCode() {
return "ga";
}
@Override
public Language getDefaultLanguageVariant() {
return DEFAULT_IRISH;
}
@Override
public Contributor[] getMaintainers() {
return new Contributor[] {
new Contributor("Jim O'Regan"),
new Contributor("Emily Barnes"),
new Contributor("Mícheál J. Ó Meachair"),
new Contributor("Seanán Ó Coistín")
};
}
@Override
public List<Rule> getRelevantRules(ResourceBundle messages, UserConfig userConfig, Language motherTongue, List<Language> altLanguages) throws IOException {
return Arrays.asList(
new CommaWhitespaceRule(messages),
new GenericUnpairedBracketsRule(messages,
Arrays.asList("[", "(", "{", "\"", "“"),
Arrays.asList("]", ")", "}", "\"", "”")),
new DoublePunctuationRule(messages),
new UppercaseSentenceStartRule(messages, this),
new LongSentenceRule(messages, userConfig, -1, true),
new LongParagraphRule(messages, this, userConfig),
new UppercaseSentenceStartRule(messages, this),
new MultipleWhitespaceRule(messages, this),
new SentenceWhitespaceRule(messages),
new WhiteSpaceBeforeParagraphEnd(messages, this),
new WhiteSpaceAtBeginOfParagraph(messages),
new ParagraphRepeatBeginningRule(messages, this),
new WordRepeatRule(messages, this),
new MorfologikIrishSpellerRule(messages, this, userConfig, altLanguages),
new LogainmRule(messages),
new PeopleRule(messages),
new SpacesRule(messages),
new CompoundRule(messages),
new PrestandardReplaceRule(messages),
new IrishReplaceRule(messages),
new IrishFGBEqReplaceRule(messages),
new EnglishHomophoneRule(messages),
new DhaNoBeirtRule(messages),
new DativePluralStandardReplaceRule(messages),
new IrishSpecificCaseRule(messages)
);
}
@NotNull
@Override
public Tagger createDefaultTagger() {
return new IrishTagger();
}
@Nullable
@Override
public Synthesizer createDefaultSynthesizer() {
return new IrishSynthesizer(this);
}
@Override
public SentenceTokenizer createDefaultSentenceTokenizer() {
return new SRXSentenceTokenizer(this);
}
@Override
public Disambiguator createDefaultDisambiguator() {
return new IrishHybridDisambiguator();
}
@Override
public Tokenizer createDefaultWordTokenizer() {
return new WordTokenizer();
}
@Override
public LanguageMaintainedState getMaintainedState() {
return LanguageMaintainedState.ActivelyMaintained;
}
@Override
public synchronized LanguageModel getLanguageModel(File indexDir) throws IOException {
languageModel = initLanguageModel(indexDir, languageModel);
return languageModel;
}
@Override
public void close() throws Exception {
if (languageModel != null) {
languageModel.close();
}
}
@Override
protected int getPriorityForId(String id) {
switch (id) {
case "TOO_LONG_PARAGRAPH": return -15;
}
return super.getPriorityForId(id);
}
}
| 30.290909 | 157 | 0.72609 |
1a5ccb619504aeab791aedd3167788c96ed171d8 | 4,799 | /*
* Copyright 2017 StreamSets 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.streamsets.pipeline.lib.io;
import java.io.ByteArrayInputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
/**
* A <code>LiveFileChunk</code> is a data segmented of a {@link LiveFile} that is guaranteed to be comprised of
* full text lines.
*/
public class LiveFileChunk {
private final String tag;
private final LiveFile file;
private final byte[] data;
private final Charset charset;
private final long dataOffset;
private final int length;
private final boolean truncated;
private final List<FileLine> lines;
// creates a chunk using existing FileLines instead of a raw buffer to create them
LiveFileChunk(String tag, LiveFile file, Charset charset, List<FileLine> lines, boolean truncated) {
this.tag = tag;
this.file = file;
this.charset = charset;
data = null;
dataOffset = -1;
length = -1;
this.lines = lines;
this.truncated = truncated;
}
// creates a chunk using a raw buffer and creates the FileLines from it
LiveFileChunk(String tag, LiveFile file, Charset charset, byte[] data, long dataOffset, int length,
boolean truncated) {
this.tag = tag;
this.file = file;
this.data = data;
this.charset = charset;
this.dataOffset = dataOffset;
this.length = length;
lines = createLines();
this.truncated = truncated;
}
/**
* Returns the tag associated with file where the chunk was read from.
*
* @return the tag associated with file where the chunk was read from.
*/
public String getTag() {
return tag;
}
/**
* Returns the file the chunk was read from.
*
* @return the file the chunk was read from.
*/
public LiveFile getFile() {
return file;
}
/**
* Returns the chunk charset.
*
* @return the chunk charset.
*/
public Charset getCharset() {
return charset;
}
/**
* Returns the chunk buffer. It is reference, do not modify.
*
* @return the chunk buffer. It is reference, do not modify.
*/
public byte[] getBuffer() {
return data;
}
/**
* Returns a {@link Reader} to the data in the chunk.
* <p/>
* The {@link Reader} is created using the {@link java.nio.charset.Charset} specified in the {@link SingleLineLiveFileReader}.
*
* @return a {@link Reader} to the data in the chunk.
*/
public Reader getReader() {
return new InputStreamReader(new ByteArrayInputStream(data, 0, length), charset);
}
/**
* Returns the byte offset of the chunk in the {@link LiveFile}.
*
* @return the byte offset of the chunk in the {@link LiveFile}.
*/
public long getOffset() {
return dataOffset;
}
/**
* Returns the byte length of the data in the chunk.
*
* @return the byte length of the data in the chunk.
*/
public int getLength() {
return length;
}
/**
* Returns if the chunk has been truncated. This happens if the last line of the data chunk exceeds the maximum
* length specified in the {@link SingleLineLiveFileReader}.
*
* @return <code>true</code> if the chunk has been truncated, <code>false</code> if not.
*/
public boolean isTruncated() {
return truncated;
}
/**
* Returns a list with the {@link FileLine} in the chunk. Using <code>FileLine</code>s gives access to the
* byte offset of each line (which is important when using multi-byte character encodings).
*
* @return a list with the {@link FileLine} in the chunk.
*/
public List<FileLine> getLines() {
return lines;
}
private List<FileLine> createLines() {
List<FileLine> lines = new ArrayList<>();
int start = 0;
for (int i = 0; i < length; i++) {
if (data[i] == '\n') {
lines.add(new FileLine(this, start, i + 1 - start));
start = i + 1;
} else if (data[i] == '\r') {
if (i + 1 < length && data[i + 1] == '\n') {
lines.add(new FileLine(this, start, i + 2 - start));
start = i + 2;
i++;
}
}
}
if (start < length) {
lines.add(new FileLine(this, start, length - start));
}
return lines;
}
}
| 28.064327 | 128 | 0.651177 |
fe76f48588e4d70fda66af782b96d249c8e20e9d | 5,584 | /**
*
* Copyright (c) 2017 Yoshio Terada
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package com.yoshio3.services;
import com.yoshio3.rest.entities.bot.childelements.Conversation;
import com.yoshio3.rest.entities.bot.childelements.From;
import com.yoshio3.rest.entities.bot.childelements.Members;
import com.yoshio3.rest.entities.bot.MessageBackToBotFramework;
import com.yoshio3.rest.entities.bot.MessageFromBotFrameWork;
import com.yoshio3.rest.entities.bot.childelements.Recipient;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.time.Instant;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
/**
*
* @author Yoshio Terada
*/
public class BotService{
private final static Logger LOGGER = Logger.getLogger(BotService.class.getName());
private final static String COVERSATIONS = "/v3/conversations/";
private final static String ACTIVITIES = "/activities";
public void sendResponse(MessageFromBotFrameWork requestMessage, String accessToken, String message) {
MessageBackToBotFramework creaeteResponseMessage = creaeteResponseMessage(requestMessage, message);
LOGGER.log(Level.FINE, "Back Messages:{0}", creaeteResponseMessage.toString());
Jsonb jsonb = JsonbBuilder.create();
String jsonData = jsonb.toJson(creaeteResponseMessage);
String serviceUrl = requestMessage.getServiceUrl();
String id = requestMessage.getId();
String convID = requestMessage.getConversation().getId();
try {
convID = URLEncoder.encode(convID, "UTF-8");
} catch (UnsupportedEncodingException ex) {
LOGGER.log(Level.SEVERE, "UTF-8 is not supported", ex);
}
String uri = serviceUrl + COVERSATIONS + convID + ACTIVITIES; // + id;
Response response = ClientBuilder.newBuilder()
.build()
.target(uri)
.request(MediaType.APPLICATION_JSON)
.header("Authorization", "Bearer " + accessToken)
.post(Entity.entity(jsonData, MediaType.APPLICATION_JSON));
if (!isRequestSuccess(response)) {
LOGGER.log(Level.SEVERE, "{0}:{1}", new Object[]{response.getStatus(), response.readEntity(String.class)});
handleIllegalState(response);
}
}
public MessageBackToBotFramework creaeteResponseMessage(MessageFromBotFrameWork requestMessage, String message) {
MessageBackToBotFramework resMsg = new MessageBackToBotFramework();
resMsg.setType("message");
//// 2016-08-18T09:31:31.756Z (UTC Time)
Instant instant = Instant.now();
String currentUTC = instant.toString();
resMsg.setTimestamp(currentUTC);
From from = new From();
from.setId(requestMessage.getRecipient().getId());
from.setName(requestMessage.getRecipient().getName());
resMsg.setFrom(from);
Conversation conversation = new Conversation();
conversation.setId(requestMessage.getConversation().getId());
resMsg.setConversation(conversation);
Recipient recipient = new Recipient();
recipient.setId(requestMessage.getRecipient().getId());
recipient.setName(requestMessage.getRecipient().getName());
resMsg.setRecipient(recipient);
Members member = new Members();
member.setId(requestMessage.getFrom().getId());
member.setName(requestMessage.getFrom().getName());
Members[] members = new Members[1];
members[0] = member;
resMsg.setMembers(members);
resMsg.setText(message);
resMsg.setReplyToId(requestMessage.getId());
return resMsg;
}
private boolean isRequestSuccess(Response response) {
Response.StatusType statusInfo = response.getStatusInfo();
Response.Status.Family family = statusInfo.getFamily();
return family != null && family == Response.Status.Family.SUCCESSFUL;
}
/*
Operate when the REST invocaiton failed.
*/
private void handleIllegalState(Response response)
throws IllegalStateException {
String error = response.readEntity(String.class);
Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, error);
throw new IllegalStateException(error);
}
}
| 41.058824 | 119 | 0.703976 |
4c8334357829d63524cb5da897c04b0f5d6b0988 | 6,212 | /**
*
*/
package org.sagacity.sqltoy.plugins.id.macro.impl;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.sagacity.sqltoy.model.IgnoreKeyCaseMap;
import org.sagacity.sqltoy.plugins.id.macro.AbstractMacro;
import org.sagacity.sqltoy.utils.BeanUtil;
import org.sagacity.sqltoy.utils.CollectionUtil;
import org.sagacity.sqltoy.utils.DateUtil;
/**
* @project sagacity-sqltoy
* @description 此类不用于主键策略的配置,提供在sql中通过@loop(:args,loopContent,linkSign,start,end)
* 函数来循环组织sql(借用主键里面的宏工具来完成@loop处理)
* @author zhongxuchen
* @version v1.0, Date:2020-9-23
* @modify 2021-10-14 支持@loop(:args,and args[i].xxx,linkSign,start,end)
* args[i].xxx对象属性模式
*/
public class SqlLoop extends AbstractMacro {
/**
* 匹配sql片段中的参数名称,包含:xxxx.xxx对象属性形式
*/
private final static Pattern paramPattern = Pattern
.compile("\\:sqlToyLoopAsKey_\\d+A(\\.[a-zA-Z\u4e00-\u9fa5][0-9a-zA-Z\u4e00-\u9fa5_]*)?\\W");
@Override
public String execute(String[] params, IgnoreKeyCaseMap<String, Object> keyValues) {
if (params == null || params.length < 2 || keyValues == null || keyValues.size() == 0) {
return " ";
}
// 剔除为了规避宏参数切割附加的符号
String varStr;
for (int i = 0; i < params.length; i++) {
varStr = params[i].trim();
if ((varStr.startsWith("'") && varStr.endsWith("'")) || (varStr.startsWith("\"") && varStr.endsWith("\""))
|| (varStr.startsWith("{") && varStr.endsWith("}"))) {
varStr = varStr.substring(1, varStr.length() - 1);
}
params[i] = varStr;
}
// 循环依据的数组参数
String loopParam = params[0].trim();
// 剔除:符号
if (loopParam.startsWith(":")) {
loopParam = loopParam.substring(1).trim();
}
// 循环内容
String loopContent = params[1];
// 循环连接符号(字符串)
String linkSign = (params.length > 2) ? params[2] : " ";
// 获取循环依据的参数数组值
Object[] loopValues = CollectionUtil.convertArray(keyValues.get(loopParam));
// 返回@blank(:paramName),便于#[ and @loop(:name,"name like ':name[i]'"," or ")]
// 先loop后没有参数导致#[]中内容全部被剔除的缺陷
if (loopValues == null || loopValues.length == 0) {
return " @blank(:" + loopParam + ") ";
}
int start = 0;
int end = loopValues.length;
if (params.length > 3) {
start = Integer.parseInt(params[3].trim());
}
if (start > loopValues.length - 1) {
return " @blank(:" + loopParam + ") ";
}
if (params.length > 4) {
end = Integer.parseInt(params[4].trim());
}
if (end >= loopValues.length) {
end = loopValues.length;
}
// 提取循环体内的参数对应的值
List<String> keys = new ArrayList<String>();
List<Object[]> regParamValues = new ArrayList<Object[]>();
String lowContent = loopContent.toLowerCase();
String key;
Enumeration<String> keyEnums = keyValues.keys();
int index = 0;
while (keyEnums.hasMoreElements()) {
key = keyEnums.nextElement().toLowerCase();
// 统一标准为paramName[i]模式
if (lowContent.contains(":" + key + "[i]") || lowContent.contains(":" + key + "[index]")) {
keys.add(key);
// 统一转为:sqlToyLoopAsKey_1_模式,简化后续匹配
loopContent = loopContent.replaceAll("(?i)\\:" + key + "\\[index\\]",
":sqlToyLoopAsKey_" + index + "A");
loopContent = loopContent.replaceAll("(?i)\\:" + key + "\\[i\\]", ":sqlToyLoopAsKey_" + index + "A");
regParamValues.add(CollectionUtil.convertArray(keyValues.get(key)));
index++;
}
}
StringBuilder result = new StringBuilder();
result.append(" @blank(:" + loopParam + ") ");
String loopStr;
index = 0;
String[] loopParamNames;
Object[] loopParamValues;
Map<String, String[]> loopParamNamesMap = parseParams(loopContent);
for (int i = start; i < end; i++) {
loopStr = loopContent;
if (index > 0) {
result.append(" ");
result.append(linkSign);
}
result.append(" ");
// 替换paramName[i]或paramName[i].xxxx
for (int j = 0; j < keys.size(); j++) {
key = ":sqlToyLoopAsKey_" + j + "A";
loopParamNames = loopParamNamesMap.get(key);
// paramName[i] 模式
if (loopParamNames.length == 0) {
loopStr = loopStr.replaceAll(key, toString(regParamValues.get(j)[i]));
} else {
// paramName[i].xxxx 模式
loopParamValues = BeanUtil.reflectBeanToAry(regParamValues.get(j)[i], loopParamNames);
for (int k = 0; k < loopParamNames.length; k++) {
loopStr = loopStr.replaceAll(key.concat(".").concat(loopParamNames[k]),
toString(loopParamValues[k]));
}
}
}
result.append(loopStr);
index++;
}
result.append(" ");
return result.toString();
}
/**
* @TODO 将参数值转成字符传
* @param paramValue
* @return
*/
private static String toString(Object paramValue) {
String valueStr;
if (paramValue instanceof Date || paramValue instanceof LocalDateTime) {
valueStr = "" + DateUtil.formatDate(paramValue, "yyyy-MM-dd HH:mm:ss");
} else if (paramValue instanceof LocalDate) {
valueStr = "" + DateUtil.formatDate(paramValue, "yyyy-MM-dd");
} else if (paramValue instanceof LocalTime) {
valueStr = "" + DateUtil.formatDate(paramValue, "HH:mm:ss");
} else {
valueStr = "" + paramValue;
}
return valueStr;
}
/**
* @todo 解析模板中的参数
* @param template
* @return
*/
public static Map<String, String[]> parseParams(String template) {
Map<String, String[]> paramsMap = new HashMap<String, String[]>();
Matcher m = paramPattern.matcher(template.concat(" "));
String group;
String key;
int dotIndex;
while (m.find()) {
group = m.group();
group = group.substring(0, group.length() - 1);
dotIndex = group.indexOf(".");
if (dotIndex != -1) {
key = group.substring(0, dotIndex);
String[] items = paramsMap.get(key);
if (items == null) {
paramsMap.put(key, new String[] { group.substring(dotIndex + 1) });
} else {
String[] newItems = new String[items.length + 1];
newItems[items.length] = group.substring(dotIndex + 1);
System.arraycopy(items, 0, newItems, 0, items.length);
paramsMap.put(key, newItems);
}
} else {
paramsMap.put(group, new String[] {});
}
}
return paramsMap;
}
}
| 31.532995 | 109 | 0.645364 |
301ef7d631abfc1e835b10e00e5a4f38ef5d5996 | 12,791 | package seedu.address.model;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static seedu.address.testutil.TypicalPersons.AMY;
import static seedu.address.testutil.TypicalPersons.BOB;
import static seedu.address.testutil.TypicalPersons.CARL;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import seedu.address.testutil.ContactListBuilder;
public class VersionedContactListTest {
private final ReadOnlyContactList contactListWithAmy = new ContactListBuilder().withPerson(AMY).build();
private final ReadOnlyContactList contactListWithBob = new ContactListBuilder().withPerson(BOB).build();
private final ReadOnlyContactList contactListWithCarl = new ContactListBuilder().withPerson(CARL).build();
private final ReadOnlyContactList emptyContactList = new ContactListBuilder().build();
@Test
public void commit_singleContactList_noStatesRemovedCurrentStateSaved() {
VersionedContactList versionedContactList = prepareContactListList(emptyContactList);
versionedContactList.commit();
assertContactListListStatus(versionedContactList,
Collections.singletonList(emptyContactList),
emptyContactList,
Collections.emptyList());
}
@Test
public void commit_multipleContactListPointerAtEndOfStateList_noStatesRemovedCurrentStateSaved() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
versionedContactList.commit();
assertContactListListStatus(versionedContactList,
Arrays.asList(emptyContactList, contactListWithAmy, contactListWithBob),
contactListWithBob,
Collections.emptyList());
}
@Test
public void commit_multipleContactListPointerNotAtEndOfStateList_statesAfterPointerRemovedCurrentStateSaved() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 2);
versionedContactList.commit();
assertContactListListStatus(versionedContactList,
Collections.singletonList(emptyContactList),
emptyContactList,
Collections.emptyList());
}
@Test
public void canUndo_multipleContactListPointerAtEndOfStateList_returnsTrue() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
assertTrue(versionedContactList.canUndo());
}
@Test
public void canUndo_multipleContactListPointerAtStartOfStateList_returnsTrue() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 1);
assertTrue(versionedContactList.canUndo());
}
@Test
public void canUndo_singleContactList_returnsFalse() {
VersionedContactList versionedContactList = prepareContactListList(emptyContactList);
assertFalse(versionedContactList.canUndo());
}
@Test
public void canUndo_multipleContactListPointerAtStartOfStateList_returnsFalse() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 2);
assertFalse(versionedContactList.canUndo());
}
@Test
public void canRedo_multipleContactListPointerNotAtEndOfStateList_returnsTrue() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 1);
assertTrue(versionedContactList.canRedo());
}
@Test
public void canRedo_multipleContactListPointerAtStartOfStateList_returnsTrue() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 2);
assertTrue(versionedContactList.canRedo());
}
@Test
public void canRedo_singleContactList_returnsFalse() {
VersionedContactList versionedContactList = prepareContactListList(emptyContactList);
assertFalse(versionedContactList.canRedo());
}
@Test
public void canRedo_multipleContactListPointerAtEndOfStateList_returnsFalse() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
assertFalse(versionedContactList.canRedo());
}
@Test
public void undo_multipleContactListPointerAtEndOfStateList_success() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
versionedContactList.undo();
assertContactListListStatus(versionedContactList,
Collections.singletonList(emptyContactList),
contactListWithAmy,
Collections.singletonList(contactListWithBob));
}
@Test
public void undo_multipleContactListPointerNotAtStartOfStateList_success() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 1);
versionedContactList.undo();
assertContactListListStatus(versionedContactList,
Collections.emptyList(),
emptyContactList,
Arrays.asList(contactListWithAmy, contactListWithBob));
}
@Test
public void undo_singleContactList_throwsNoUndoableStateException() {
VersionedContactList versionedContactList = prepareContactListList(emptyContactList);
assertThrows(VersionedContactList.NoUndoableStateException.class, versionedContactList::undo);
}
@Test
public void undo_multipleContactListPointerAtStartOfStateList_throwsNoUndoableStateException() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 2);
assertThrows(VersionedContactList.NoUndoableStateException.class, versionedContactList::undo);
}
@Test
public void redo_multipleContactListPointerNotAtEndOfStateList_success() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 1);
versionedContactList.redo();
assertContactListListStatus(versionedContactList,
Arrays.asList(emptyContactList, contactListWithAmy),
contactListWithBob,
Collections.emptyList());
}
@Test
public void redo_multipleContactListPointerAtStartOfStateList_success() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 2);
versionedContactList.redo();
assertContactListListStatus(versionedContactList,
Collections.singletonList(emptyContactList),
contactListWithAmy,
Collections.singletonList(contactListWithBob));
}
@Test
public void redo_singleContactList_throwsNoRedoableStateException() {
VersionedContactList versionedContactList = prepareContactListList(emptyContactList);
assertThrows(VersionedContactList.NoRedoableStateException.class, versionedContactList::redo);
}
@Test
public void redo_multipleContactListPointerAtEndOfStateList_throwsNoRedoableStateException() {
VersionedContactList versionedContactList = prepareContactListList(
emptyContactList, contactListWithAmy, contactListWithBob);
assertThrows(VersionedContactList.NoRedoableStateException.class, versionedContactList::redo);
}
@Test
public void equals() {
VersionedContactList versionedContactList = prepareContactListList(contactListWithAmy, contactListWithBob);
// same values -> returns true
VersionedContactList copy = prepareContactListList(contactListWithAmy, contactListWithBob);
assertTrue(versionedContactList.equals(copy));
// same object -> returns true
assertTrue(versionedContactList.equals(versionedContactList));
// null -> returns false
assertFalse(versionedContactList.equals(null));
// different types -> returns false
assertFalse(versionedContactList.equals(1));
// different state list -> returns false
VersionedContactList differentContactListList = prepareContactListList(contactListWithBob, contactListWithCarl);
assertFalse(versionedContactList.equals(differentContactListList));
// different current pointer index -> returns false
VersionedContactList differentCurrentStatePointer = prepareContactListList(
contactListWithAmy, contactListWithBob);
shiftCurrentStatePointerLeftwards(versionedContactList, 1);
assertFalse(versionedContactList.equals(differentCurrentStatePointer));
}
/**
* Asserts that {@code versionedContactList} is currently pointing at {@code expectedCurrentState},
* states before {@code versionedContactList#currentStatePointer} is equal to {@code expectedStatesBeforePointer},
* and states after {@code versionedContactList#currentStatePointer} is equal to {@code expectedStatesAfterPointer}.
*/
private void assertContactListListStatus(VersionedContactList versionedContactList,
List<ReadOnlyContactList> expectedStatesBeforePointer,
ReadOnlyContactList expectedCurrentState,
List<ReadOnlyContactList> expectedStatesAfterPointer) {
// check state currently pointing at is correct
assertEquals(new ContactList(versionedContactList), expectedCurrentState);
// shift pointer to start of state list
while (versionedContactList.canUndo()) {
versionedContactList.undo();
}
// check states before pointer are correct
for (ReadOnlyContactList expectedContactList : expectedStatesBeforePointer) {
assertEquals(expectedContactList, new ContactList(versionedContactList));
versionedContactList.redo();
}
// check states after pointer are correct
for (ReadOnlyContactList expectedContactList : expectedStatesAfterPointer) {
versionedContactList.redo();
assertEquals(expectedContactList, new ContactList(versionedContactList));
}
// check that there are no more states after pointer
assertFalse(versionedContactList.canRedo());
// revert pointer to original position
expectedStatesAfterPointer.forEach(unused -> versionedContactList.undo());
}
/**
* Creates and returns a {@code VersionedContactList} with the {@code contactListStates} added into it, and the
* {@code VersionedContactList#currentStatePointer} at the end of list.
*/
private VersionedContactList prepareContactListList(ReadOnlyContactList... contactListStates) {
assertFalse(contactListStates.length == 0);
VersionedContactList versionedContactList = new VersionedContactList(contactListStates[0]);
for (int i = 1; i < contactListStates.length; i++) {
versionedContactList.resetData(contactListStates[i]);
versionedContactList.commit();
}
return versionedContactList;
}
/**
* Shifts the {@code versionedContactList#currentStatePointer} by {@code count} to the left of its list.
*/
private void shiftCurrentStatePointerLeftwards(VersionedContactList versionedContactList, int count) {
for (int i = 0; i < count; i++) {
versionedContactList.undo();
}
}
}
| 42.779264 | 120 | 0.731843 |
06563320c8fced9c7a2d61f96c064c7884793b06 | 146 | package com.justcorrections.grit.data;
public class StorageHelper {
public static final String USER_PROFILE_PATH = "User_Profile_Images";
}
| 20.857143 | 73 | 0.794521 |
fec9cac69b970747821eaf34767b1b0ef183f7c7 | 428 | package iuniversity.controller.exams;
import java.time.LocalDate;
import iuniversity.model.didactics.Course;
import iuniversity.model.exams.ExamCall.ExamType;
public interface ExamCreationController {
void initializeChoices();
void initializeExamTypeChoices();
void initilizeCourseChoices();
void publishExamCall(LocalDate callStart, Course course, ExamType examType,
int maximumStudents);
}
| 21.4 | 79 | 0.775701 |
2e6e350ee6bc01683f10ce628ab4e45e7bfad220 | 836 | package org.audit4j.microservice.core;
import java.io.Serializable;
public class Ack implements Serializable{
/**
*
*/
private static final long serialVersionUID = -8707468501787579530L;
private String message;
private int code;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public static Ack SUCCESS(){
Ack ack = new Ack();
ack.setCode(200);
ack.setMessage("success");
return ack;
}
public static Ack FAIL(){
Ack ack = new Ack();
ack.setCode(500);
ack.setMessage("fail");
return ack;
}
public static Ack UNAUTHORIZED(){
Ack ack = new Ack();
ack.setCode(401);
ack.setMessage("unauthorized");
return ack;
}
}
| 15.773585 | 68 | 0.675837 |
207e8a89ef3d501044136e0ae92ee76267924497 | 1,121 | package cl.injcristianrojas.spring.data.dao.impl;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import cl.injcristianrojas.spring.data.dao.PersonDAO;
import cl.injcristianrojas.spring.data.model.Person;
@SuppressWarnings("unchecked")
@Repository
public class PersonDAOImpl implements PersonDAO {
@Autowired
private SessionFactory sessionFactory;
@Override
public List<Person> getAllPersons() {
Session session = sessionFactory.openSession();
String hql = "from Person";
Query query = session.createQuery(hql);
return query.list();
}
@Override
public void insertPerson(Person person) {
Session session = sessionFactory.openSession();
session.save(person);
}
@Override
public List<Person> getPersonsOfType(String type) {
Session session = sessionFactory.openSession();
String hql = "from Person p where p.type = '" + type + "'";
Query query = session.createQuery(hql);
return query.list();
}
}
| 24.369565 | 62 | 0.767172 |
eb6d5ea5f9a726efd953c1db647ad1c1a47193af | 1,847 | /*******************************************************************************
* Copyright 2009-2018 Exactpro (Exactpro Systems Limited)
*
* 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.exactprosystems.jf.tool.git.reset;
import com.exactprosystems.jf.tool.git.CredentialBean;
import com.exactprosystems.jf.tool.git.GitUtil;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.revwalk.RevCommit;
import java.util.Date;
import java.util.List;
public class GitResetBean
{
private RevCommit commit;
private CredentialBean bean;
public GitResetBean(RevCommit commit, CredentialBean bean)
{
this.commit = commit;
this.bean = bean;
}
public String getCommitId()
{
return this.commit.getName();
}
public Date getDate()
{
return this.commit.getAuthorIdent().getWhen();
}
public String getMessage()
{
return this.commit.getFullMessage();
}
public String getUsername()
{
PersonIdent authorIdent = this.commit.getAuthorIdent();
return authorIdent.getName() + "<" + authorIdent.getEmailAddress() + ">";
}
public List<FileWithStatusBean> getFiles() throws Exception
{
return GitUtil.getCommitFiles(bean, commit);
}
@Override
public String toString()
{
return this.commit.toString();
}
}
| 26.385714 | 80 | 0.67948 |
e35f39eec34afa1cda09bcce42eb4771d317ba45 | 3,438 | /*
* Copyright 2015 the original author or authors.
* @https://github.com/scouter-project/scouter
*
* 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 scouterx.webapp.request;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;
import scouterx.webapp.framework.client.server.ServerManager;
import scouterx.webapp.framework.exception.ErrorState;
import javax.validation.constraints.NotNull;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
/**
* @author Gun Lee (gunlee01@gmail.com) on 2017. 8. 27.
*/
@Getter
@Setter
@ToString
public class CounterRequest {
private final long limitRangeSec = 6 * 60 * 60; //6 hour
private int serverId;
@NotNull
@PathParam("counter")
private String counter;
//exclusive with startTimeMillis
@QueryParam("startYmdHms")
private String startYmdHms;
//exclusive with endTimeMillis
@QueryParam("endYmdHms")
private String endYmdHms;
@QueryParam("startTimeMillis")
private long startTimeMillis;
@QueryParam("endTimeMillis")
private long endTimeMillis;
@QueryParam("serverId")
public void setServerId(int serverId) {
this.serverId = ServerManager.getInstance().getServerIfNullDefault(serverId).getId();
}
public void validate() {
if (StringUtils.isNotBlank(startYmdHms) || StringUtils.isNotBlank(endYmdHms)) {
if (StringUtils.isBlank(startYmdHms) || StringUtils.isBlank(endYmdHms)) {
throw ErrorState.VALIDATE_ERROR.newBizException("startYmdHms and endYmdHms should be not null !");
}
if (startTimeMillis > 0 || endTimeMillis > 0) {
throw ErrorState.VALIDATE_ERROR.newBizException("startYmdHms, endYmdHms and startTimeMillis, endTimeMills must not coexist!");
}
setTimeAsYmd();
} else {
if (startTimeMillis <= 0 || endTimeMillis <= 0) {
throw ErrorState.VALIDATE_ERROR.newBizException("startTimeMillis and endTimeMillis must have value!");
}
}
if (endTimeMillis - startTimeMillis > limitRangeSec * 1000L) {
throw ErrorState.VALIDATE_ERROR.newBizException("query range should be lower than " + limitRangeSec + " seconds!");
}
}
private void setTimeAsYmd() {
ZoneId zoneId = ZoneId.systemDefault();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
LocalDateTime startDateTime = LocalDateTime.parse(startYmdHms, formatter);
LocalDateTime endDateTime = LocalDateTime.parse(endYmdHms, formatter);
startTimeMillis = startDateTime.atZone(zoneId).toEpochSecond() * 1000L;
endTimeMillis = endDateTime.atZone(zoneId).toEpochSecond() * 1000L;
}
}
| 34.38 | 142 | 0.703898 |
d1e6732b4b63b430132063103c097ab18a0710db | 288 | package de.epages.ws.order7;
import de.epages.ws.WebServiceConfiguration;
import de.epages.ws.order7.stub.OrderService;
import de.epages.ws.order7.stub.Port_Order;
public interface OrderServiceStubFactory {
Port_Order create(WebServiceConfiguration config, OrderService service);
}
| 28.8 | 76 | 0.826389 |
119ea714d2de38a072294823f8134b44acf2ebee | 1,095 | package com.antyzero.fadingactionbar.example;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* Created by iwopolanski on 28.01.15.
*/
public class RandomTextGenerator {
private static final String ALPHABET = "abcdefghijklmnoprstquwxzABCDEFGHIJKLMNOPRSTQUWXZ";
private List<String> wordsList = new ArrayList<>();
private Random random = new Random();
public RandomTextGenerator() {
this( 793L );
}
public RandomTextGenerator( long randomSeed ) {
random.setSeed( randomSeed );
}
public String generate() {
StringBuilder stringBuilder = new StringBuilder();
for ( int i = 0; i < random.nextInt( 290 ) + 10; i++ ) {
StringBuilder workBuilder = new StringBuilder();
for ( int j = 0; j < random.nextInt( 15 ) + 1; j++ ) {
workBuilder.append( ALPHABET.charAt( random.nextInt( ALPHABET.length() ) ) );
}
stringBuilder.append( workBuilder.toString() ).append( " " );
}
return stringBuilder.toString();
}
}
| 24.333333 | 94 | 0.625571 |
8a181092fb3beace0584ae34eefd8e9837775967 | 926 | /*******************************************************************************
* Copyright (c) 2019-10-29 @author <a href="mailto:iffiff1@gmail.com">Tyler Chen</a>.
* All rights reserved.
*
* Contributors:
* <a href="mailto:iffiff1@gmail.com">Tyler Chen</a> - initial API and implementation.
******************************************************************************/
package org.iff.springboot.config;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.persistence.EntityManager;
/**
* @author <a href="mailto:iffiff1@gmail.com">Tyler Chen</a>
* @since 2019-10-29
* auto generate by qdp.
*/
@Configuration
public class QueryDslConfig {
@Bean
public JPAQueryFactory getJPAQueryFactory(EntityManager entityManager) {
return new JPAQueryFactory(entityManager);
}
} | 34.296296 | 90 | 0.615551 |
17d844181d333fa64cc04343f5eedf85be55f076 | 2,538 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class ClientSocketTask11 {
private Socket socket = null;
private BufferedReader in;
private PrintWriter out;
public ClientSocketTask11(String ip, int port) {
try {
System.out.println("Connecting to server...");
socket = new Socket(ip, port);
System.out.println("Connected");
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(), true);
} catch (IOException e) {
System.out.println("Error >> " + e.getMessage());
}
}
private int sendQuery(String query) {
out.println(query);
try {
String response = in.readLine();
String[] fields = response.split("#");
System.out.println(response);
if (fields.length == 1) {
System.out.println("Invalid response from server");
}
try {
int compCode = Integer.parseInt(fields[0]);
if (compCode == 0) {
System.out.println("\n\nQuery:");
for (int i = 1; i < fields.length - 1; ++i) {
System.out.print(fields[i]);
System.out.print("; ");
}
System.out.println("\nResult:");
System.out.println(fields[fields.length - 1]);
return 0;
} else {
System.out.println("Error while processing query");
return -1;
}
} catch (NumberFormatException e) {
System.out.println("Invalid response from server");
return -1;
}
} catch (IOException e) {
System.out.println(">> " + e.getMessage());
return -1;
}
}
public void disconnect() {
try {
socket.close();
} catch (IOException e) {
System.out.println("Error >> " + e.getMessage());
}
}
public static void main(String[] args) {
ClientSocketTask11 client = new ClientSocketTask11("localhost", 7272);
client.sendQuery("routeNum,13");
client.sendQuery("olderThan,50");
client.sendQuery("mileageBiggerThan,300000");
client.disconnect();
}
} | 32.126582 | 84 | 0.516942 |
ee8701e05e0dd5da33b403b8643421c527acd23f | 307 | // "Replace with text block" "true"
class TextBlockMigration {
void concatenationWithMultipleNewLines() {
String html = "<html>\n" +<caret>
" <body>\n" +
" <p>Hello, world</p>\n" +
" </body>\n" +
"</html>\n";
}
} | 25.583333 | 51 | 0.429967 |
09ce419aa84ad62a192fe65ea7cc3db38f19660c | 3,605 | /*
* Copyright 2014 Dan Haywood
*
* 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.isisaddons.app.kitchensink.dom.hierarchy;
import java.util.List;
import javax.inject.Inject;
import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import org.apache.isis.applib.DomainObjectContainer;
import org.apache.isis.applib.annotation.Action;
import org.apache.isis.applib.annotation.DomainService;
import org.apache.isis.applib.annotation.MemberOrder;
import org.apache.isis.applib.annotation.NatureOfService;
import org.apache.isis.applib.annotation.ParameterLayout;
import org.apache.isis.applib.annotation.SemanticsOf;
import org.isisaddons.app.kitchensink.dom.hierarchy.child.ChildObject;
import org.isisaddons.app.kitchensink.dom.hierarchy.child.ChildObjects;
import org.isisaddons.app.kitchensink.dom.hierarchy.grandchild.GrandchildObject;
import org.isisaddons.app.kitchensink.dom.hierarchy.grandchild.GrandchildObjects;
import org.isisaddons.app.kitchensink.dom.hierarchy.parent.ParentObject;
import org.isisaddons.app.kitchensink.dom.hierarchy.parent.ParentObjects;
@DomainService(
nature = NatureOfService.VIEW_MENU_ONLY,
menuOrder = "10.10"
)
public class HierarchyObjects {
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "10")
public ParentObject firstParent() {
return parentObjects.first();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "11")
public ParentObject findParent(
@ParameterLayout(named="Title")
final String title) {
final Optional<ParentObject> parentObjectIfAny =
Iterables.tryFind(parentObjects.listAll(), input -> container.titleOf(input).contains(title));
return parentObjectIfAny.orNull();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "11.1")
public ParentObject findParentUnique(String name) {
return parentObjects.findUnique(name);
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "12")
public List<ParentObject> allParents() {
return parentObjects.listAll();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "20")
public ChildObject firstChild() {
return childObjects.first();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "21")
public List<ChildObject> allChildren() {
return childObjects.listAll();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "30")
public GrandchildObject firstGrandchild() {
return grandchildObjects.first();
}
@Action(semantics = SemanticsOf.SAFE)
@MemberOrder(sequence = "31")
public List<GrandchildObject> allGrandChildren() {
return grandchildObjects.listAll();
}
@Inject
private ParentObjects parentObjects;
@Inject
private ChildObjects childObjects;
@Inject
private GrandchildObjects grandchildObjects;
@Inject
DomainObjectContainer container;
}
| 29.793388 | 110 | 0.726491 |
34cb240878eb3c537665049e9a870f9c08705a76 | 4,930 | /*
* 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 co.edu.uniandes.csw.turismo.test.logic;
import co.edu.uniandes.csw.turismo.ejb.CiudadLogic;
import co.edu.uniandes.csw.turismo.entities.CiudadEntity;
import co.edu.uniandes.csw.turismo.exceptions.BusinessLogicException;
import co.edu.uniandes.csw.turismo.persistence.CiudadPersistence;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.UserTransaction;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import uk.co.jemos.podam.api.PodamFactory;
import uk.co.jemos.podam.api.PodamFactoryImpl;
/**
*
* @author david Fonseca
*/
@RunWith(Arquillian.class)
public class CiudadLogicTest {
private final PodamFactory factory = new PodamFactoryImpl();
@Inject
private CiudadLogic paisLogic;
@Inject
private CiudadPersistence ep;
@PersistenceContext
private EntityManager em;
@Inject
private UserTransaction utx;
private final List<CiudadEntity> data = new ArrayList<>();
@Deployment
public static JavaArchive createDeployment() {
return ShrinkWrap.create(JavaArchive.class)
.addPackage(CiudadEntity.class.getPackage())
.addPackage(CiudadPersistence.class.getPackage())
.addPackage(CiudadLogic.class.getPackage())
.addAsManifestResource("META-INF/persistence.xml", "persistence.xml")
.addAsManifestResource("META-INF/beans.xml", "beans.xml");
}
@Before
public void configTest() {
try {
utx.begin();
clearData();
insertData();
utx.commit();
} catch (Exception e) {
e.printStackTrace();
try {
utx.rollback();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
private void clearData() {
em.createQuery("delete from CiudadEntity").executeUpdate();
}
private void insertData() {
for (int i = 0; i < 3; i++) {
CiudadEntity newCiudadEntity = factory.manufacturePojo(CiudadEntity.class);
em.persist(newCiudadEntity);
data.add(newCiudadEntity);
}
}
@Test
public void createCiudadTest() throws BusinessLogicException {
CiudadEntity newCiudadEntity = factory.manufacturePojo(CiudadEntity.class);
CiudadEntity result = ep.create(newCiudadEntity);
Assert.assertNotNull(result);
CiudadEntity entity = em.find(CiudadEntity.class, result.getId());
Assert.assertEquals(newCiudadEntity.darNombre(), entity.darNombre());
}
@Test(expected = BusinessLogicException.class)
public void createCiudadConNombreInvalidoTest() throws BusinessLogicException {
CiudadEntity newEntity = factory.manufacturePojo(CiudadEntity.class);
newEntity.actualizarNombre("");
paisLogic.createCiudad(newEntity);
}
@Test
public void updateCiudadTest() throws BusinessLogicException {
CiudadEntity entity = data.get(0);
entity.actualizarNombre("hola");
CiudadEntity pojoEntity = factory.manufacturePojo(CiudadEntity.class);
pojoEntity.actualizarNombre(entity.darNombre());
pojoEntity.setId(entity.getId());
paisLogic.updateCiudad(pojoEntity.getId(), pojoEntity);
CiudadEntity resp = em.find(CiudadEntity.class, entity.getId());
Assert.assertEquals(pojoEntity.getId(), resp.getId());
Assert.assertEquals(pojoEntity.darNombre(), resp.darNombre());
Assert.assertEquals(pojoEntity.darPlanes(), resp.darPlanes());
}
@Test(expected = BusinessLogicException.class)
public void updateCiudadConNombreVacioTest() throws BusinessLogicException {
CiudadEntity entity = data.get(0);
CiudadEntity pojoEntity = factory.manufacturePojo(CiudadEntity.class);
pojoEntity.actualizarNombre("");
paisLogic.updateCiudad(entity.getId(), pojoEntity);
}
@Test(expected = BusinessLogicException.class)
public void updateCiudadConNombreNuloTest() throws BusinessLogicException {
CiudadEntity entity = data.get(0);
CiudadEntity pojoEntity = factory.manufacturePojo(CiudadEntity.class);
pojoEntity.actualizarNombre(null);
paisLogic.updateCiudad(entity.getId(), pojoEntity);
}
}
| 32.222222 | 87 | 0.683367 |
c0725a86b6f4d046ccf984ce60bb66c0dd788e08 | 2,908 | package com.huanmedia.videochat.common.widget.dialog;
import android.app.Dialog;
import android.content.Context;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.text.InputType;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;
import android.widget.TextView;
import com.huanmedia.videochat.R;
public class EditTextDialog extends Dialog implements View.OnClickListener {
private EditText mETContent;
private TextView mTVTitle;
private TextView mTVEditTitle;
private TextView mTVSubmit;
private String mTitleStr;
private String mEditTitleStr;
private String mEditContentStr;
private int mInputType;
private CallBack mCallBack;
public EditTextDialog(@NonNull Context context) {
super(context, R.style.customDialog);
mTitleStr = "";
mEditTitleStr = "";
mEditContentStr = "";
mInputType = InputType.TYPE_CLASS_TEXT;
}
/***
* 设置标题
* @param title
*/
public void setTitle(String title) {
mTitleStr = title;
}
/**
* 设置输入框标题
*
* @param title
*/
public void setEditTitle(String title) {
mEditTitleStr = title;
}
public void setEditContent(String content) {
mEditContentStr = content;
}
/**
* 设置回调
*
* @param callBack
*/
public void setCallBack(CallBack callBack) {
mCallBack = callBack;
}
/**
* 设置输入类型
*
* @param inputType
*/
public void setInputType(int inputType) {
mInputType = inputType;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.dialog_edittext);
if (getWindow() != null) {
getWindow().getAttributes().gravity = Gravity.CENTER;
getWindow().getAttributes().width = ViewGroup.LayoutParams.MATCH_PARENT;
}
initView();
initData();
}
private void initView() {
mETContent = findViewById(R.id.et_content);
mTVTitle = findViewById(R.id.tv_title);
mTVEditTitle = findViewById(R.id.tv_edit_title);
mTVSubmit = findViewById(R.id.tv_submit);
mTVSubmit.setOnClickListener(this);
}
private void initData() {
mTVTitle.setText(mTitleStr);
mTVEditTitle.setText(mEditTitleStr);
mETContent.setInputType(mInputType);
mETContent.setText(mEditContentStr);
}
@Override
public void onClick(View view) {
if (view == mTVSubmit) {
if (mCallBack != null)
mCallBack.submitOnClick(EditTextDialog.this, mETContent.getText().toString());
}
cancel();
}
public interface CallBack {
void submitOnClick(Dialog view, String content);
}
}
| 24.436975 | 94 | 0.641678 |
8d432c2d50021b0241e88eafc9dafac3f4d1d025 | 2,449 | /*
* Artifactory is a binaries repository manager.
* Copyright (C) 2012 JFrog Ltd.
*
* Artifactory is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Artifactory is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Artifactory. If not, see <http://www.gnu.org/licenses/>.
*/
package org.artifactory.version.converter.v147;
import org.artifactory.version.converter.XmlConverter;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.Namespace;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
/**
* @author Noam Y. Tenne
*/
public class UnusedArtifactCleanupSwitchConverter implements XmlConverter {
@SuppressWarnings({"UnusedDeclaration"})
private static final Logger log = LoggerFactory.getLogger(UnusedArtifactCleanupSwitchConverter.class);
@Override
public void convert(Document doc) {
log.info("Starting the unused artifact cleanup switch conversion");
Element rootElement = doc.getRootElement();
Namespace namespace = rootElement.getNamespace();
log.debug("Converting remote repositories");
Element remoteRepositoriesElement = rootElement.getChild("remoteRepositories", namespace);
if (remoteRepositoriesElement != null) {
List<Element> remoteRepositoryElements =
remoteRepositoriesElement.getChildren("remoteRepository", namespace);
if (remoteRepositoryElements != null && !remoteRepositoryElements.isEmpty()) {
for (Element remoteRepositoryElement : remoteRepositoryElements) {
log.debug("Removing unused artifact cleanup switch from '{}'",
remoteRepositoryElement.getChild("key", namespace).getText());
remoteRepositoryElement.removeChild("unusedArtifactsCleanupEnabled", namespace);
}
}
}
log.info("Ending the unused artifact cleanup switch conversion");
}
}
| 38.265625 | 106 | 0.710902 |
2edce443e0999020334043a40f8586564f61a899 | 376 | package com.alipay.api.response;
import com.alipay.api.AlipayResponse;
/**
* ALIPAY API: alipay.ins.auto.user.oil.exchange response.
*
* @author auto create
* @since 1.0, 2019-07-04 17:35:01
*/
public class AlipayInsAutoUserOilExchangeResponse extends AlipayResponse {
private static final long serialVersionUID = 1469645637156763719L;
}
| 17.904762 | 75 | 0.710106 |
e19387239d4d16357f6d278ac460acf34429d8e9 | 3,513 | package co.edu.javeriana.configuracion.error;
import co.edu.javeriana.configuracion.utils.BundleUtil;
import co.edu.javeriana.configuracion.utils.error.ProcessError;
import co.edu.javeriana.configuracion.utils.error.ProcessError;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MessageUtils implements Serializable{
@SuppressWarnings("compatibility:-7032184438660535596")
private static final long serialVersionUID = 1L;
public static final Integer TYPE_MSJ_INFO=1;
public static final Integer TYPE_MSJ_WARNING=2;
public static final String MSJ_OBLIGATORIO="Los siguientes campos son requeridos:";
private ProcessError process;
private List<String> listaCampos;
private List<MensajeTipificado> mensajes;
private Boolean error;
private Boolean msj;
public MessageUtils() {
super();
this.process= new ProcessError();
}
public Boolean error() {
return error;
}
public Boolean msj() {
return msj;
}
public void clean(){
if(this.listaCampos!=null){
this.listaCampos.clear();
}
if(this.mensajes!=null){
this.mensajes.clear();
}
this.error=Boolean.FALSE;
this.msj=Boolean.FALSE;
}
public void addMessageWithType(final String variable,final String key,final Integer type){
if(this.mensajes==null){
this.mensajes= new ArrayList<MensajeTipificado>();
}
this.mensajes.add(new MensajeTipificado(type,BundleUtil.getString(variable, key)));
this.msj=Boolean.TRUE;
}
public void addMessageWithType(final String msj,final Integer type){
if(this.mensajes==null){
this.mensajes= new ArrayList<MensajeTipificado>();
}
this.mensajes.add(new MensajeTipificado(type,msj));
this.msj=Boolean.TRUE;
}
public void agregarCampoObligatorio(String variable,String key){
if(this.listaCampos==null){
this.listaCampos= new ArrayList<String>();
}
String label = BundleUtil.getString(variable, key).replace(":", "");
this.listaCampos.add(label);
this.error=Boolean.TRUE;
}
public String[] getMessage(){
String[] res= new String[2];
StringBuilder inf= new StringBuilder ("");
StringBuilder warning= new StringBuilder ("");
Iterator<MensajeTipificado> it=this.mensajes.iterator();
while(it.hasNext()){
MensajeTipificado item=it.next();
if(item.getTipo().equals(MessageUtils.TYPE_MSJ_INFO)){
inf.append(item.getMsj()+"<br/>");
}
if(item.getTipo().equals(MessageUtils.TYPE_MSJ_WARNING)){
warning.append(item.getMsj()+"<br/>");
}
}
res[0]=inf.toString();
res[1]=warning.toString();
return res;
}
public void process(){
this.process.process(this);
}
public String getListMessage(){
StringBuilder res= new StringBuilder ("<p>"+MessageUtils.MSJ_OBLIGATORIO+"</p>");
Iterator<String> it=this.listaCampos.iterator();
while(it.hasNext()){
String tmp=it.next();
res.append(tmp+"<br/>");
}
return res.toString();
}
public void setProcess(ProcessError process) {
this.process = process;
}
public ProcessError getProcess() {
return process;
}
}
| 32.527778 | 94 | 0.633931 |
e39c6ebed0ee091e5c98d3fc3eda69d908659b58 | 659,679 | import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class RegressionTest35 {
public static boolean debug = false;
@Test
public void test17501() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17501");
java.io.Serializable[] serializableArray4 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet5 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray4);
java.io.Serializable[] serializableArray7 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet8 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray7);
java.io.Serializable[] serializableArray9 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet10 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray9);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray7, (java.lang.Object[]) serializableArray9);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) serializableArray9);
java.io.Serializable[] serializableArray14 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet15 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray14);
java.io.Serializable[] serializableArray17 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet18 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray17);
java.io.Serializable[] serializableArray19 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet20 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray19);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray17, (java.lang.Object[]) serializableArray19);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray14, (java.lang.Object[]) serializableArray19);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) serializableArray14);
java.util.concurrent.ExecutorService[] executorServiceArray24 = new java.util.concurrent.ExecutorService[] {};
boolean boolean25 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray24);
org.junit.Assert.assertEquals("tests.slow", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) executorServiceArray24);
java.io.Serializable[] serializableArray28 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet29 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray28);
java.io.Serializable[] serializableArray31 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet32 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray31);
java.io.Serializable[] serializableArray34 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet35 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray34);
java.io.Serializable[] serializableArray36 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet37 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray36);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray34, (java.lang.Object[]) serializableArray36);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray31, (java.lang.Object[]) serializableArray36);
org.junit.Assert.assertArrayEquals("tests.nightly", (java.lang.Object[]) serializableArray28, (java.lang.Object[]) serializableArray36);
org.junit.Assert.assertArrayEquals("tests.weekly", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) serializableArray28);
int[][] intArray42 = new int[][] {};
java.util.Set<int[]> intArraySet43 = org.apache.lucene.util.LuceneTestCase.asSet(intArray42);
java.io.Serializable[] serializableArray45 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet46 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray45);
java.io.Serializable[] serializableArray47 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet48 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray47);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray45, (java.lang.Object[]) serializableArray47);
java.util.concurrent.ExecutorService[] executorServiceArray50 = new java.util.concurrent.ExecutorService[] {};
boolean boolean51 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray50);
boolean boolean52 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray50);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray45, (java.lang.Object[]) executorServiceArray50);
org.junit.Assert.assertNotEquals((java.lang.Object) intArray42, (java.lang.Object) serializableArray45);
java.util.Set<int[]> intArraySet55 = org.apache.lucene.util.LuceneTestCase.asSet(intArray42);
org.junit.Assert.assertEquals((java.lang.Object[]) serializableArray4, (java.lang.Object[]) intArray42);
org.junit.Assert.assertNotNull(serializableArray4);
org.junit.Assert.assertNotNull(serializableSet5);
org.junit.Assert.assertNotNull(serializableArray7);
org.junit.Assert.assertNotNull(serializableSet8);
org.junit.Assert.assertNotNull(serializableArray9);
org.junit.Assert.assertNotNull(serializableSet10);
org.junit.Assert.assertNotNull(serializableArray14);
org.junit.Assert.assertNotNull(serializableSet15);
org.junit.Assert.assertNotNull(serializableArray17);
org.junit.Assert.assertNotNull(serializableSet18);
org.junit.Assert.assertNotNull(serializableArray19);
org.junit.Assert.assertNotNull(serializableSet20);
org.junit.Assert.assertNotNull(executorServiceArray24);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + true + "'", boolean25 == true);
org.junit.Assert.assertNotNull(serializableArray28);
org.junit.Assert.assertNotNull(serializableSet29);
org.junit.Assert.assertNotNull(serializableArray31);
org.junit.Assert.assertNotNull(serializableSet32);
org.junit.Assert.assertNotNull(serializableArray34);
org.junit.Assert.assertNotNull(serializableSet35);
org.junit.Assert.assertNotNull(serializableArray36);
org.junit.Assert.assertNotNull(serializableSet37);
org.junit.Assert.assertNotNull(intArray42);
org.junit.Assert.assertNotNull(intArraySet43);
org.junit.Assert.assertNotNull(serializableArray45);
org.junit.Assert.assertNotNull(serializableSet46);
org.junit.Assert.assertNotNull(serializableArray47);
org.junit.Assert.assertNotNull(serializableSet48);
org.junit.Assert.assertNotNull(executorServiceArray50);
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + true + "'", boolean51 == true);
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + true + "'", boolean52 == true);
org.junit.Assert.assertNotNull(intArraySet55);
}
@Test
public void test17502() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17502");
byte[] byteArray3 = new byte[] {};
byte[] byteArray4 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray3, byteArray4);
byte[] byteArray8 = new byte[] {};
byte[] byteArray9 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray8, byteArray9);
byte[] byteArray12 = new byte[] {};
byte[] byteArray13 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray12, byteArray13);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray8, byteArray12);
byte[] byteArray18 = new byte[] {};
byte[] byteArray19 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray18, byteArray19);
byte[] byteArray22 = new byte[] {};
byte[] byteArray23 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray22, byteArray23);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray18, byteArray22);
org.junit.Assert.assertArrayEquals(byteArray12, byteArray18);
org.junit.Assert.assertArrayEquals("", byteArray3, byteArray12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests28 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests28.tearDown();
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests28.assertTermsEquals("tests.failfast", indexReader31, terms32, terms33, false);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests28.assertDocsSkippingEquals("tests.nightly", indexReader37, (int) (byte) -1, postingsEnum39, postingsEnum40, false);
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
kuromojiAnalysisTests28.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader44, (int) (short) -1, postingsEnum46, postingsEnum47);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests50 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule51 = kuromojiAnalysisTests50.ruleChain;
kuromojiAnalysisTests50.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests50);
org.junit.rules.RuleChain ruleChain54 = kuromojiAnalysisTests50.failureAndSuccessEvents;
kuromojiAnalysisTests28.failureAndSuccessEvents = ruleChain54;
org.apache.lucene.index.IndexReader indexReader57 = null;
org.apache.lucene.index.PostingsEnum postingsEnum59 = null;
org.apache.lucene.index.PostingsEnum postingsEnum60 = null;
kuromojiAnalysisTests28.assertDocsSkippingEquals("tests.badapples", indexReader57, 0, postingsEnum59, postingsEnum60, true);
kuromojiAnalysisTests28.ensureCheckIndexPassed();
kuromojiAnalysisTests28.ensureCheckIndexPassed();
kuromojiAnalysisTests28.overrideTestDefaultQueryCache();
kuromojiAnalysisTests28.overrideTestDefaultQueryCache();
org.junit.Assert.assertNotEquals("<unknown>", (java.lang.Object) byteArray12, (java.lang.Object) kuromojiAnalysisTests28);
org.apache.lucene.index.PostingsEnum postingsEnum69 = null;
org.apache.lucene.index.PostingsEnum postingsEnum70 = null;
kuromojiAnalysisTests28.assertDocsEnumEquals("hi!", postingsEnum69, postingsEnum70, true);
org.apache.lucene.index.IndexReader indexReader74 = null;
org.apache.lucene.index.Terms terms75 = null;
org.apache.lucene.index.Terms terms76 = null;
kuromojiAnalysisTests28.assertTermsEquals("random", indexReader74, terms75, terms76, true);
kuromojiAnalysisTests28.tearDown();
kuromojiAnalysisTests28.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests28.ensureCleanedUp();
org.junit.Assert.assertNotNull(byteArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray3), "[]");
org.junit.Assert.assertNotNull(byteArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray4), "[]");
org.junit.Assert.assertNotNull(byteArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray8), "[]");
org.junit.Assert.assertNotNull(byteArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray9), "[]");
org.junit.Assert.assertNotNull(byteArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray12), "[]");
org.junit.Assert.assertNotNull(byteArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray13), "[]");
org.junit.Assert.assertNotNull(byteArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray18), "[]");
org.junit.Assert.assertNotNull(byteArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray19), "[]");
org.junit.Assert.assertNotNull(byteArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray22), "[]");
org.junit.Assert.assertNotNull(byteArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray23), "[]");
org.junit.Assert.assertNotNull(testRule51);
org.junit.Assert.assertNotNull(ruleChain54);
}
@Test
public void test17503() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17503");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum37, postingsEnum38, false);
org.junit.rules.TestRule testRule41 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '#');
kuromojiAnalysisTests0.resetCheckIndexStatus();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testIterationMarkCharFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(testRule41);
}
@Test
public void test17504() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17504");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("tests.weekly", indexReader7, (int) (short) 1, postingsEnum9, postingsEnum10);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests12 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests12.tearDown();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Terms terms16 = null;
org.apache.lucene.index.Terms terms17 = null;
kuromojiAnalysisTests12.assertTermsEquals("tests.failfast", indexReader15, terms16, terms17, false);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests12.assertDocsSkippingEquals("tests.nightly", indexReader21, (int) (byte) -1, postingsEnum23, postingsEnum24, false);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
kuromojiAnalysisTests12.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader28, (int) (short) -1, postingsEnum30, postingsEnum31);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests34 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule35 = kuromojiAnalysisTests34.ruleChain;
kuromojiAnalysisTests34.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests34);
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests34.failureAndSuccessEvents;
kuromojiAnalysisTests12.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.tearDown();
org.junit.Assert.assertNotNull("hi!", (java.lang.Object) kuromojiAnalysisTests2);
kuromojiAnalysisTests2.ensureCleanedUp();
kuromojiAnalysisTests2.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum48 = null;
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
kuromojiAnalysisTests2.assertDocsSkippingEquals("tests.awaitsfix", indexReader46, (-1), postingsEnum48, postingsEnum49, true);
java.lang.String str52 = kuromojiAnalysisTests2.getTestName();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests2);
org.junit.Assert.assertNotNull(testRule3);
org.junit.Assert.assertNotNull(testRule35);
org.junit.Assert.assertNotNull(ruleChain38);
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "<unknown>" + "'", str52, "<unknown>");
}
@Test
public void test17505() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17505");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomRealisticUnicodeOfCodepointLengthBetween(1, 2);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17506() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17506");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Terms terms11 = null;
org.apache.lucene.index.Terms terms12 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader10, terms11, terms12, false);
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
kuromojiAnalysisTests1.tearDown();
java.lang.Object obj17 = null;
org.junit.Assert.assertNotEquals("tests.slow", (java.lang.Object) kuromojiAnalysisTests1, obj17);
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.assertPathHasBeenCleared("hi!");
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.Fields fields27 = null;
org.apache.lucene.index.Fields fields28 = null;
kuromojiAnalysisTests1.assertFieldsEquals("tests.badapples", indexReader26, fields27, fields28, true);
org.junit.Assert.assertNotNull(testRule19);
}
@Test
public void test17507() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17507");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
kuromojiAnalysisTests1.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.Terms terms12 = null;
org.apache.lucene.index.Terms terms13 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.slow", indexReader11, terms12, terms13, false);
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests19 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests19.assertTermsEquals("", indexReader21, terms22, terms23, false);
kuromojiAnalysisTests19.ensureCleanedUp();
kuromojiAnalysisTests19.ensureAllSearchContextsReleased();
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) kuromojiAnalysisTests19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests31 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule32 = kuromojiAnalysisTests31.ruleChain;
kuromojiAnalysisTests31.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests31);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
kuromojiAnalysisTests31.assertPositionsSkippingEquals("tests.weekly", indexReader36, (int) (short) 1, postingsEnum38, postingsEnum39);
java.lang.String str41 = kuromojiAnalysisTests31.getTestName();
kuromojiAnalysisTests31.setIndexWriterMaxDocs((int) 'a');
org.junit.Assert.assertNotNull("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests31);
org.junit.rules.TestRule testRule45 = kuromojiAnalysisTests31.ruleChain;
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests31);
org.junit.Assert.assertNotSame("", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) kuromojiAnalysisTests31);
org.elasticsearch.common.settings.Settings settings48 = null;
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment49 = kuromojiAnalysisTests31.newNodeEnvironment(settings48);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule32);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "<unknown>" + "'", str41, "<unknown>");
org.junit.Assert.assertNotNull(testRule45);
}
@Test
public void test17508() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17508");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.Terms terms45 = null;
org.apache.lucene.index.Terms terms46 = null;
kuromojiAnalysisTests0.assertTermsEquals("europarl.lines.txt.gz", indexReader44, terms45, terms46, false);
org.apache.lucene.index.IndexReader indexReader50 = null;
org.apache.lucene.index.Fields fields51 = null;
org.apache.lucene.index.Fields fields52 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader50, fields51, fields52, true);
org.apache.lucene.index.IndexReader indexReader56 = null;
org.apache.lucene.index.PostingsEnum postingsEnum58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum59 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader56, 5, postingsEnum58, postingsEnum59);
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '#');
org.apache.lucene.index.IndexReader indexReader64 = null;
org.apache.lucene.index.PostingsEnum postingsEnum66 = null;
org.apache.lucene.index.PostingsEnum postingsEnum67 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("europarl.lines.txt.gz", indexReader64, (int) (byte) 1, postingsEnum66, postingsEnum67, true);
org.junit.rules.RuleChain ruleChain70 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests71 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader73 = null;
org.apache.lucene.index.Terms terms74 = null;
org.apache.lucene.index.Terms terms75 = null;
kuromojiAnalysisTests71.assertTermsEquals("", indexReader73, terms74, terms75, false);
kuromojiAnalysisTests71.ensureCheckIndexPassed();
kuromojiAnalysisTests71.tearDown();
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) kuromojiAnalysisTests71);
org.apache.lucene.index.IndexReader indexReader82 = null;
org.apache.lucene.index.PostingsEnum postingsEnum84 = null;
org.apache.lucene.index.PostingsEnum postingsEnum85 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.awaitsfix", indexReader82, (int) '4', postingsEnum84, postingsEnum85, true);
org.apache.lucene.index.IndexReader indexReader89 = null;
org.apache.lucene.index.IndexReader indexReader90 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertStoredFieldsEquals("tests.failfast", indexReader89, indexReader90);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(ruleChain70);
}
@Test
public void test17509() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17509");
// The following exception was thrown during execution in test generation
try {
java.lang.String[] strArray3 = org.elasticsearch.test.ESTestCase.generateRandomStringArray((int) (byte) 100, 5, true);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17510() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17510");
org.junit.Assert.assertEquals((long) 0, 0L);
}
@Test
public void test17511() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17511");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum5 = null;
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("<unknown>", postingsEnum5, postingsEnum6, true);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Fields fields11 = null;
org.apache.lucene.index.Fields fields12 = null;
kuromojiAnalysisTests0.assertFieldsEquals("hi!", indexReader10, fields11, fields12, false);
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum17 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("random", postingsEnum16, postingsEnum17, false);
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) "tests.maxfailures");
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.failfast", indexReader27, 10, postingsEnum29, postingsEnum30, false);
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader35 = null;
org.apache.lucene.index.TermsEnum termsEnum36 = null;
org.apache.lucene.index.TermsEnum termsEnum37 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermsEnumEquals("tests.maxfailures", indexReader35, termsEnum36, termsEnum37, true);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17512() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17512");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("tests.weekly", indexReader7, (int) (short) 1, postingsEnum9, postingsEnum10);
java.lang.String str12 = kuromojiAnalysisTests2.getTestName();
kuromojiAnalysisTests2.setIndexWriterMaxDocs((int) 'a');
org.junit.Assert.assertNotNull("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests2);
org.junit.rules.TestRule testRule16 = kuromojiAnalysisTests2.ruleChain;
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests2.ruleChain;
java.nio.file.Path path18 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests2.assertPathHasBeenCleared(path18);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule3);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "<unknown>" + "'", str12, "<unknown>");
org.junit.Assert.assertNotNull(testRule16);
org.junit.Assert.assertNotNull(testRule17);
}
@Test
public void test17513() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17513");
java.util.Random random0 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests4 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule5 = kuromojiAnalysisTests4.ruleChain;
kuromojiAnalysisTests4.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests4);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.Terms terms10 = null;
org.apache.lucene.index.Terms terms11 = null;
kuromojiAnalysisTests4.assertTermsEquals("random", indexReader9, terms10, terms11, false);
org.junit.rules.RuleChain ruleChain14 = kuromojiAnalysisTests4.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.Terms terms17 = null;
org.apache.lucene.index.Terms terms18 = null;
kuromojiAnalysisTests4.assertTermsEquals("", indexReader16, terms17, terms18, true);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests21 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests21.tearDown();
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.Fields fields25 = null;
org.apache.lucene.index.Fields fields26 = null;
kuromojiAnalysisTests21.assertFieldsEquals("enwiki.random.lines.txt", indexReader24, fields25, fields26, true);
kuromojiAnalysisTests21.setUp();
kuromojiAnalysisTests21.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader33 = null;
org.apache.lucene.index.Fields fields34 = null;
org.apache.lucene.index.Fields fields35 = null;
kuromojiAnalysisTests21.assertFieldsEquals("enwiki.random.lines.txt", indexReader33, fields34, fields35, false);
org.junit.rules.TestRule testRule38 = kuromojiAnalysisTests21.ruleChain;
org.apache.lucene.index.IndexReader indexReader40 = null;
org.apache.lucene.index.PostingsEnum postingsEnum42 = null;
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
kuromojiAnalysisTests21.assertDocsSkippingEquals("tests.weekly", indexReader40, 1, postingsEnum42, postingsEnum43, false);
kuromojiAnalysisTests21.ensureAllSearchContextsReleased();
org.junit.rules.RuleChain ruleChain47 = kuromojiAnalysisTests21.failureAndSuccessEvents;
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain47;
org.junit.Assert.assertNotEquals("europarl.lines.txt.gz", (java.lang.Object) kuromojiAnalysisTests4, (java.lang.Object) ruleChain47);
org.apache.lucene.document.FieldType fieldType50 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field51 = org.apache.lucene.util.LuceneTestCase.newField(random0, "tests.badapples", (java.lang.Object) kuromojiAnalysisTests4, fieldType50);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule5);
org.junit.Assert.assertNotNull(ruleChain14);
org.junit.Assert.assertNotNull(testRule38);
org.junit.Assert.assertNotNull(ruleChain47);
}
@Test
public void test17514() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17514");
java.util.Random random0 = null;
org.apache.lucene.document.Field.Store store3 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field4 = org.apache.lucene.util.LuceneTestCase.newTextField(random0, "europarl.lines.txt.gz", "tests.slow", store3);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17515() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17515");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("enwiki.random.lines.txt", postingsEnum14, postingsEnum15, true);
kuromojiAnalysisTests1.setUp();
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
java.lang.String str20 = kuromojiAnalysisTests1.getTestName();
org.apache.lucene.index.IndexReader indexReader22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader22, (int) (short) -1, postingsEnum24, postingsEnum25);
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "<unknown>" + "'", str20, "<unknown>");
}
@Test
public void test17516() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17516");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain12 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain11);
org.junit.rules.RuleChain ruleChain13 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests15 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests15.tearDown();
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.Terms terms19 = null;
org.apache.lucene.index.Terms terms20 = null;
kuromojiAnalysisTests15.assertTermsEquals("tests.failfast", indexReader18, terms19, terms20, false);
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.Terms terms25 = null;
org.apache.lucene.index.Terms terms26 = null;
kuromojiAnalysisTests15.assertTermsEquals("", indexReader24, terms25, terms26, false);
kuromojiAnalysisTests15.overrideTestDefaultQueryCache();
kuromojiAnalysisTests15.tearDown();
org.junit.Assert.assertNotNull("<unknown>", (java.lang.Object) kuromojiAnalysisTests15);
kuromojiAnalysisTests15.assertPathHasBeenCleared("tests.weekly");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests34 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Fields fields37 = null;
org.apache.lucene.index.Fields fields38 = null;
kuromojiAnalysisTests34.assertFieldsEquals("hi!", indexReader36, fields37, fields38, false);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests42 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule43 = kuromojiAnalysisTests42.ruleChain;
kuromojiAnalysisTests42.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests42);
org.apache.lucene.index.IndexReader indexReader47 = null;
org.apache.lucene.index.Terms terms48 = null;
org.apache.lucene.index.Terms terms49 = null;
kuromojiAnalysisTests42.assertTermsEquals("random", indexReader47, terms48, terms49, false);
org.junit.rules.RuleChain ruleChain52 = kuromojiAnalysisTests42.failureAndSuccessEvents;
org.junit.runners.model.Statement statement53 = null;
org.junit.runner.Description description54 = null;
org.junit.runners.model.Statement statement55 = ruleChain52.apply(statement53, description54);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests57 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule58 = kuromojiAnalysisTests57.ruleChain;
kuromojiAnalysisTests57.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests57);
org.apache.lucene.index.IndexReader indexReader62 = null;
org.apache.lucene.index.Terms terms63 = null;
org.apache.lucene.index.Terms terms64 = null;
kuromojiAnalysisTests57.assertTermsEquals("random", indexReader62, terms63, terms64, false);
org.junit.rules.RuleChain ruleChain67 = kuromojiAnalysisTests57.failureAndSuccessEvents;
org.junit.runners.model.Statement statement68 = null;
org.junit.runner.Description description69 = null;
org.junit.runners.model.Statement statement70 = ruleChain67.apply(statement68, description69);
org.junit.runner.Description description71 = null;
org.junit.runners.model.Statement statement72 = ruleChain52.apply(statement70, description71);
org.junit.rules.TestRule testRule73 = org.apache.lucene.util.LuceneTestCase.classRules;
org.junit.rules.RuleChain ruleChain74 = org.junit.rules.RuleChain.outerRule(testRule73);
org.junit.rules.RuleChain ruleChain75 = ruleChain52.around(testRule73);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain75;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests77 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule78 = kuromojiAnalysisTests77.ruleChain;
kuromojiAnalysisTests77.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain80 = kuromojiAnalysisTests77.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain81 = ruleChain75.around((org.junit.rules.TestRule) ruleChain80);
kuromojiAnalysisTests34.failureAndSuccessEvents = ruleChain75;
kuromojiAnalysisTests15.failureAndSuccessEvents = ruleChain75;
org.junit.rules.RuleChain ruleChain84 = ruleChain12.around((org.junit.rules.TestRule) ruleChain75);
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(ruleChain11);
org.junit.Assert.assertNotNull(ruleChain12);
org.junit.Assert.assertNotNull(ruleChain13);
org.junit.Assert.assertNotNull(testRule43);
org.junit.Assert.assertNotNull(ruleChain52);
org.junit.Assert.assertNotNull(statement55);
org.junit.Assert.assertNotNull(testRule58);
org.junit.Assert.assertNotNull(ruleChain67);
org.junit.Assert.assertNotNull(statement70);
org.junit.Assert.assertNotNull(statement72);
org.junit.Assert.assertNotNull(testRule73);
org.junit.Assert.assertNotNull(ruleChain74);
org.junit.Assert.assertNotNull(ruleChain75);
org.junit.Assert.assertNotNull(testRule78);
org.junit.Assert.assertNotNull(ruleChain80);
org.junit.Assert.assertNotNull(ruleChain81);
org.junit.Assert.assertNotNull(ruleChain84);
}
@Test
public void test17517() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17517");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService19 = kuromojiAnalysisTests0.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17518() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17518");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.weekly", indexReader6, (int) (short) 1, postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests11.tearDown();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests11.assertTermsEquals("tests.failfast", indexReader14, terms15, terms16, false);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests11.assertDocsSkippingEquals("tests.nightly", indexReader20, (int) (byte) -1, postingsEnum22, postingsEnum23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests11.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader27, (int) (short) -1, postingsEnum29, postingsEnum30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.junit.rules.RuleChain ruleChain37 = kuromojiAnalysisTests33.failureAndSuccessEvents;
kuromojiAnalysisTests11.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader42 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum45 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.weekly", indexReader42, (int) 'a', postingsEnum44, postingsEnum45, true);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests1);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain37);
org.junit.Assert.assertNotNull(ruleChain50);
}
@Test
public void test17519() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17519");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests18 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests18.ruleChain;
kuromojiAnalysisTests18.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests18);
org.junit.rules.RuleChain ruleChain22 = kuromojiAnalysisTests18.failureAndSuccessEvents;
kuromojiAnalysisTests18.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) kuromojiAnalysisTests18);
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.PostingsEnum postingsEnum28 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.badapples", indexReader26, (int) 'a', postingsEnum28, postingsEnum29);
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule19);
org.junit.Assert.assertNotNull(ruleChain22);
}
@Test
public void test17520() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17520");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Fields fields38 = null;
org.apache.lucene.index.Fields fields39 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader37, fields38, fields39, false);
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.Terms terms44 = null;
org.apache.lucene.index.Terms terms45 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader43, terms44, terms45, true);
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.badapples", postingsEnum49, postingsEnum50, true);
org.apache.lucene.index.PostingsEnum postingsEnum54 = null;
org.apache.lucene.index.PostingsEnum postingsEnum55 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum54, postingsEnum55, true);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17521() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17521");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.rules.TestRule testRule5 = kuromojiAnalysisTests0.ruleChain;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testKatakanaStemFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule5);
}
@Test
public void test17522() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17522");
java.lang.Object obj1 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests3.tearDown();
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Fields fields7 = null;
org.apache.lucene.index.Fields fields8 = null;
kuromojiAnalysisTests3.assertFieldsEquals("enwiki.random.lines.txt", indexReader6, fields7, fields8, true);
kuromojiAnalysisTests3.setUp();
kuromojiAnalysisTests3.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests3.resetCheckIndexStatus();
kuromojiAnalysisTests3.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests3.assertPathHasBeenCleared("hi!");
kuromojiAnalysisTests3.ensureAllSearchContextsReleased();
org.junit.Assert.assertNotNull("tests.maxfailures", (java.lang.Object) kuromojiAnalysisTests3);
org.junit.Assert.assertNotSame("enwiki.random.lines.txt", obj1, (java.lang.Object) kuromojiAnalysisTests3);
kuromojiAnalysisTests3.setIndexWriterMaxDocs((int) (byte) 0);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests3.testReadingFormFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17523() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17523");
char[] charArray0 = null;
char[] charArray1 = null;
org.junit.Assert.assertArrayEquals(charArray0, charArray1);
}
@Test
public void test17524() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17524");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader3, terms4, terms5, false);
kuromojiAnalysisTests1.setUp();
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
kuromojiAnalysisTests1.setIndexWriterMaxDocs((int) '4');
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Terms terms14 = null;
org.apache.lucene.index.Terms terms15 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.badapples", indexReader13, terms14, terms15, true);
org.junit.Assert.assertNull("tests.monster", (java.lang.Object) terms14);
}
@Test
public void test17525() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17525");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.setUp();
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("<unknown>", postingsEnum9, postingsEnum10, false);
java.lang.String str13 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Fields fields16 = null;
org.apache.lucene.index.Fields fields17 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.badapples", indexReader15, fields16, fields17, true);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.monster", indexReader21, (int) (short) 100, postingsEnum23, postingsEnum24, true);
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "<unknown>" + "'", str13, "<unknown>");
}
@Test
public void test17526() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17526");
org.junit.Assert.assertEquals("tests.badapples", 0.0d, 10.0d, (double) (byte) 10);
}
@Test
public void test17527() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17527");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
java.lang.String str5 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader7, 0, postingsEnum9, postingsEnum10, false);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "<unknown>" + "'", str5, "<unknown>");
}
@Test
public void test17528() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17528");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.assertPathHasBeenCleared("enwiki.random.lines.txt");
kuromojiAnalysisTests0.setIndexWriterMaxDocs((-1));
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests14 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule15 = kuromojiAnalysisTests14.ruleChain;
kuromojiAnalysisTests14.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests14);
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.Terms terms20 = null;
org.apache.lucene.index.Terms terms21 = null;
kuromojiAnalysisTests14.assertTermsEquals("random", indexReader19, terms20, terms21, false);
kuromojiAnalysisTests14.ensureCheckIndexPassed();
kuromojiAnalysisTests14.ensureCheckIndexPassed();
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests14.failureAndSuccessEvents;
int[] intArray30 = new int[] {};
int[] intArray31 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray30, intArray31);
int[] intArray34 = new int[] {};
int[] intArray35 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray34, intArray35);
org.junit.Assert.assertArrayEquals(intArray31, intArray34);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray31, (java.lang.Object) 100.0d);
int[] intArray43 = new int[] {};
int[] intArray44 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray43, intArray44);
int[] intArray47 = new int[] {};
int[] intArray48 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray47, intArray48);
org.junit.Assert.assertArrayEquals(intArray44, intArray47);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray44, (java.lang.Object) 100.0d);
int[] intArray54 = new int[] {};
int[] intArray55 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray54, intArray55);
org.junit.Assert.assertArrayEquals("tests.nightly", intArray44, intArray54);
org.junit.Assert.assertArrayEquals("random", intArray31, intArray44);
int[] intArray59 = new int[] {};
org.junit.Assert.assertArrayEquals(intArray44, intArray59);
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain26, (java.lang.Object) intArray59);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests62 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests62.tearDown();
org.apache.lucene.index.IndexReader indexReader65 = null;
org.apache.lucene.index.Terms terms66 = null;
org.apache.lucene.index.Terms terms67 = null;
kuromojiAnalysisTests62.assertTermsEquals("tests.failfast", indexReader65, terms66, terms67, false);
org.apache.lucene.index.IndexReader indexReader71 = null;
org.apache.lucene.index.Terms terms72 = null;
org.apache.lucene.index.Terms terms73 = null;
kuromojiAnalysisTests62.assertTermsEquals("", indexReader71, terms72, terms73, false);
org.junit.rules.RuleChain ruleChain76 = kuromojiAnalysisTests62.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain77 = ruleChain26.around((org.junit.rules.TestRule) ruleChain76);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain76;
org.apache.lucene.index.PostingsEnum postingsEnum80 = null;
org.apache.lucene.index.PostingsEnum postingsEnum81 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("<unknown>", postingsEnum80, postingsEnum81, false);
org.apache.lucene.index.IndexReader indexReader85 = null;
org.apache.lucene.index.IndexReader indexReader86 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertNormsEquals("hi!", indexReader85, indexReader86);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule15);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(intArray30);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray30), "[]");
org.junit.Assert.assertNotNull(intArray31);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray31), "[]");
org.junit.Assert.assertNotNull(intArray34);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray34), "[]");
org.junit.Assert.assertNotNull(intArray35);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray35), "[]");
org.junit.Assert.assertNotNull(intArray43);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray43), "[]");
org.junit.Assert.assertNotNull(intArray44);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray44), "[]");
org.junit.Assert.assertNotNull(intArray47);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray47), "[]");
org.junit.Assert.assertNotNull(intArray48);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray48), "[]");
org.junit.Assert.assertNotNull(intArray54);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray54), "[]");
org.junit.Assert.assertNotNull(intArray55);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray55), "[]");
org.junit.Assert.assertNotNull(intArray59);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray59), "[]");
org.junit.Assert.assertNotNull(ruleChain76);
org.junit.Assert.assertNotNull(ruleChain77);
}
@Test
public void test17529() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17529");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomUnicodeOfLengthBetween((int) 'a', (int) (byte) 1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17530() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17530");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader16, 1, postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests25 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule26 = kuromojiAnalysisTests25.ruleChain;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.junit.rules.RuleChain ruleChain29 = org.junit.rules.RuleChain.outerRule(testRule26);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests30 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule31 = kuromojiAnalysisTests30.ruleChain;
org.junit.rules.RuleChain ruleChain32 = org.junit.rules.RuleChain.outerRule(testRule31);
org.junit.rules.RuleChain ruleChain33 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain32);
org.junit.rules.RuleChain ruleChain34 = ruleChain29.around((org.junit.rules.TestRule) ruleChain33);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain33;
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Terms terms38 = null;
org.apache.lucene.index.Terms terms39 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.nightly", indexReader37, terms38, terms39, true);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.junit.Assert.assertNotNull(testRule26);
org.junit.Assert.assertNotNull(ruleChain29);
org.junit.Assert.assertNotNull(testRule31);
org.junit.Assert.assertNotNull(ruleChain32);
org.junit.Assert.assertNotNull(ruleChain33);
org.junit.Assert.assertNotNull(ruleChain34);
}
@Test
public void test17531() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17531");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("hi!", indexReader17, 4, postingsEnum19, postingsEnum20);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("hi!");
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("europarl.lines.txt.gz", indexReader27, 0, postingsEnum29, postingsEnum30);
java.lang.String str32 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.setUp();
org.apache.lucene.index.PostingsEnum postingsEnum35 = null;
org.apache.lucene.index.PostingsEnum postingsEnum36 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.nightly", postingsEnum35, postingsEnum36, false);
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertEquals("'" + str32 + "' != '" + "<unknown>" + "'", str32, "<unknown>");
}
@Test
public void test17532() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17532");
java.util.Random random0 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule4 = kuromojiAnalysisTests3.ruleChain;
kuromojiAnalysisTests3.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests3);
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Terms terms9 = null;
org.apache.lucene.index.Terms terms10 = null;
kuromojiAnalysisTests3.assertTermsEquals("random", indexReader8, terms9, terms10, false);
kuromojiAnalysisTests3.ensureCheckIndexPassed();
kuromojiAnalysisTests3.ensureCleanedUp();
org.junit.rules.TestRule testRule15 = kuromojiAnalysisTests3.ruleChain;
org.junit.rules.RuleChain ruleChain16 = org.junit.rules.RuleChain.outerRule(testRule15);
org.apache.lucene.document.FieldType fieldType17 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field18 = org.apache.lucene.util.LuceneTestCase.newField(random0, "tests.badapples", (java.lang.Object) ruleChain16, fieldType17);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule4);
org.junit.Assert.assertNotNull(testRule15);
org.junit.Assert.assertNotNull(ruleChain16);
}
@Test
public void test17533() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17533");
org.junit.Assert.assertNotEquals("hi!", (long) (short) -1, (long) 3);
}
@Test
public void test17534() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17534");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.weekly", indexReader44, (int) (short) 100, postingsEnum46, postingsEnum47);
org.junit.rules.TestRule testRule49 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.maxfailures");
java.lang.String str52 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests0);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testIterationMarkCharFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(testRule49);
org.junit.Assert.assertEquals("'" + str52 + "' != '" + "<unknown>" + "'", str52, "<unknown>");
}
@Test
public void test17535() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17535");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.maxfailures", postingsEnum18, postingsEnum19, false);
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.Fields fields24 = null;
org.apache.lucene.index.Fields fields25 = null;
kuromojiAnalysisTests0.assertFieldsEquals("", indexReader23, fields24, fields25, true);
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
org.junit.rules.TestRule testRule30 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.setIndexWriterMaxDocs((-1));
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule30);
}
@Test
public void test17536() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17536");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
java.lang.String str10 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.junit.rules.TestRule testRule12 = kuromojiAnalysisTests0.ruleChain;
java.io.Serializable[] serializableArray13 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet14 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray13);
java.io.Serializable[] serializableArray15 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet16 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray15);
java.io.Serializable[] serializableArray17 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet18 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray17);
java.io.Serializable[] serializableArray19 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet20 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray19);
java.io.Serializable[] serializableArray21 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet22 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray21);
java.util.Set[] setArray24 = new java.util.Set[5];
@SuppressWarnings("unchecked")
java.util.Set<java.io.Serializable>[] serializableSetArray25 = (java.util.Set<java.io.Serializable>[]) setArray24;
serializableSetArray25[0] = serializableSet14;
serializableSetArray25[1] = serializableSet16;
serializableSetArray25[2] = serializableSet18;
serializableSetArray25[3] = serializableSet20;
serializableSetArray25[4] = serializableSet22;
java.util.Set<java.util.Set<java.io.Serializable>> serializableSetSet36 = org.apache.lucene.util.LuceneTestCase.asSet(serializableSetArray25);
java.util.Set<java.util.Set<java.io.Serializable>> serializableSetSet37 = org.apache.lucene.util.LuceneTestCase.asSet(serializableSetArray25);
java.util.Set<java.util.Collection<java.io.Serializable>> serializableCollectionSet38 = org.apache.lucene.util.LuceneTestCase.asSet((java.util.Collection<java.io.Serializable>[]) serializableSetArray25);
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) serializableSetArray25);
org.junit.rules.RuleChain ruleChain40 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "<unknown>" + "'", str10, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain11);
org.junit.Assert.assertNotNull(testRule12);
org.junit.Assert.assertNotNull(serializableArray13);
org.junit.Assert.assertNotNull(serializableSet14);
org.junit.Assert.assertNotNull(serializableArray15);
org.junit.Assert.assertNotNull(serializableSet16);
org.junit.Assert.assertNotNull(serializableArray17);
org.junit.Assert.assertNotNull(serializableSet18);
org.junit.Assert.assertNotNull(serializableArray19);
org.junit.Assert.assertNotNull(serializableSet20);
org.junit.Assert.assertNotNull(serializableArray21);
org.junit.Assert.assertNotNull(serializableSet22);
org.junit.Assert.assertNotNull(setArray24);
org.junit.Assert.assertNotNull(serializableSetArray25);
org.junit.Assert.assertNotNull(serializableSetSet36);
org.junit.Assert.assertNotNull(serializableSetSet37);
org.junit.Assert.assertNotNull(serializableCollectionSet38);
org.junit.Assert.assertNotNull(ruleChain40);
}
@Test
public void test17537() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17537");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 100);
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.IndexReader indexReader12 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertStoredFieldsEquals("", indexReader11, indexReader12);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17538() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17538");
org.junit.Assert.assertEquals((float) 10L, (float) 0, (float) '4');
}
@Test
public void test17539() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17539");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '4');
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Terms terms13 = null;
org.apache.lucene.index.Terms terms14 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.badapples", indexReader12, terms13, terms14, true);
java.lang.Class<?> wildcardClass17 = kuromojiAnalysisTests0.getClass();
org.junit.Assert.assertNotNull(wildcardClass17);
}
@Test
public void test17540() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17540");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.weekly", indexReader6, (int) (short) 1, postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests11.tearDown();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests11.assertTermsEquals("tests.failfast", indexReader14, terms15, terms16, false);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests11.assertDocsSkippingEquals("tests.nightly", indexReader20, (int) (byte) -1, postingsEnum22, postingsEnum23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests11.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader27, (int) (short) -1, postingsEnum29, postingsEnum30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.junit.rules.RuleChain ruleChain37 = kuromojiAnalysisTests33.failureAndSuccessEvents;
kuromojiAnalysisTests11.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.tearDown();
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum45 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.slow", indexReader43, (int) '4', postingsEnum45, postingsEnum46);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests48 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests48.tearDown();
org.apache.lucene.index.IndexReader indexReader51 = null;
org.apache.lucene.index.Fields fields52 = null;
org.apache.lucene.index.Fields fields53 = null;
kuromojiAnalysisTests48.assertFieldsEquals("enwiki.random.lines.txt", indexReader51, fields52, fields53, true);
kuromojiAnalysisTests48.resetCheckIndexStatus();
kuromojiAnalysisTests48.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests59 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests59.tearDown();
org.apache.lucene.index.IndexReader indexReader62 = null;
org.apache.lucene.index.Terms terms63 = null;
org.apache.lucene.index.Terms terms64 = null;
kuromojiAnalysisTests59.assertTermsEquals("tests.failfast", indexReader62, terms63, terms64, false);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.PostingsEnum postingsEnum70 = null;
org.apache.lucene.index.PostingsEnum postingsEnum71 = null;
kuromojiAnalysisTests59.assertDocsSkippingEquals("tests.nightly", indexReader68, (int) (byte) -1, postingsEnum70, postingsEnum71, false);
org.junit.rules.RuleChain ruleChain74 = kuromojiAnalysisTests59.failureAndSuccessEvents;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures75 = null;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures76 = org.apache.lucene.util.LuceneTestCase.replaceMaxFailureRule(testRuleIgnoreAfterMaxFailures75);
org.junit.rules.RuleChain ruleChain77 = ruleChain74.around((org.junit.rules.TestRule) testRuleIgnoreAfterMaxFailures76);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling79 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray80 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling79 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet81 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray80);
java.util.List<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingList82 = org.elasticsearch.test.ESTestCase.randomSubsetOf(0, throttlingArray80);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling83 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray84 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling83 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet85 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray84);
org.junit.Assert.assertEquals((java.lang.Object[]) throttlingArray80, (java.lang.Object[]) throttlingArray84);
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain74, (java.lang.Object) throttlingArray84);
org.junit.Assert.assertNotNull("tests.failfast", (java.lang.Object) ruleChain74);
kuromojiAnalysisTests48.failureAndSuccessEvents = ruleChain74;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain74;
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader93 = null;
org.apache.lucene.index.PostingsEnum postingsEnum95 = null;
org.apache.lucene.index.PostingsEnum postingsEnum96 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("", indexReader93, (int) 'a', postingsEnum95, postingsEnum96);
kuromojiAnalysisTests1.setUp();
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain37);
org.junit.Assert.assertNotNull(ruleChain74);
// flaky: org.junit.Assert.assertNull(testRuleIgnoreAfterMaxFailures76);
org.junit.Assert.assertNotNull(ruleChain77);
org.junit.Assert.assertTrue("'" + throttling79 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling79.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray80);
org.junit.Assert.assertNotNull(throttlingSet81);
org.junit.Assert.assertNotNull(throttlingList82);
org.junit.Assert.assertTrue("'" + throttling83 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling83.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray84);
org.junit.Assert.assertNotNull(throttlingSet85);
}
@Test
public void test17541() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17541");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.nightly", indexReader6, (int) ' ', postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule12 = kuromojiAnalysisTests11.ruleChain;
org.apache.lucene.util.LuceneTestCase.classRules = testRule12;
org.apache.lucene.util.LuceneTestCase.classRules = testRule12;
org.junit.rules.RuleChain ruleChain15 = org.junit.rules.RuleChain.outerRule(testRule12);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain15;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.weekly", postingsEnum19, postingsEnum20, false);
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.IndexReader indexReader25 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderEquals("tests.awaitsfix", indexReader24, indexReader25);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule12);
org.junit.Assert.assertNotNull(ruleChain15);
}
@Test
public void test17542() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17542");
short[] shortArray1 = new short[] {};
short[] shortArray2 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray1, shortArray2);
short[] shortArray6 = new short[] {};
short[] shortArray7 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray6, shortArray7);
short[] shortArray11 = new short[] {};
short[] shortArray12 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray11, shortArray12);
short[] shortArray15 = new short[] {};
short[] shortArray16 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray15, shortArray16);
org.junit.Assert.assertArrayEquals(shortArray11, shortArray15);
short[] shortArray20 = new short[] {};
short[] shortArray21 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray20, shortArray21);
short[] shortArray24 = new short[] {};
short[] shortArray25 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray24, shortArray25);
org.junit.Assert.assertArrayEquals(shortArray20, shortArray24);
org.junit.Assert.assertArrayEquals("tests.awaitsfix", shortArray11, shortArray24);
org.junit.Assert.assertArrayEquals("tests.nightly", shortArray6, shortArray11);
short[] shortArray31 = new short[] {};
short[] shortArray32 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray31, shortArray32);
short[] shortArray35 = new short[] {};
short[] shortArray36 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray35, shortArray36);
org.junit.Assert.assertArrayEquals(shortArray31, shortArray35);
org.junit.Assert.assertArrayEquals(shortArray11, shortArray31);
short[] shortArray42 = new short[] {};
short[] shortArray43 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray42, shortArray43);
short[] shortArray46 = new short[] {};
short[] shortArray47 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray46, shortArray47);
org.junit.Assert.assertArrayEquals(shortArray42, shortArray46);
short[] shortArray52 = new short[] {};
short[] shortArray53 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray52, shortArray53);
short[] shortArray56 = new short[] {};
short[] shortArray57 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray56, shortArray57);
org.junit.Assert.assertArrayEquals(shortArray52, shortArray56);
short[] shortArray61 = new short[] {};
short[] shortArray62 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray61, shortArray62);
short[] shortArray65 = new short[] {};
short[] shortArray66 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray65, shortArray66);
org.junit.Assert.assertArrayEquals(shortArray61, shortArray65);
org.junit.Assert.assertArrayEquals("<unknown>", shortArray52, shortArray65);
org.junit.Assert.assertArrayEquals("", shortArray46, shortArray52);
short[] shortArray73 = new short[] {};
short[] shortArray74 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray73, shortArray74);
short[] shortArray77 = new short[] {};
short[] shortArray78 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray77, shortArray78);
org.junit.Assert.assertArrayEquals("", shortArray74, shortArray77);
org.junit.Assert.assertArrayEquals(shortArray52, shortArray77);
org.junit.Assert.assertArrayEquals(shortArray31, shortArray77);
org.junit.Assert.assertArrayEquals(shortArray2, shortArray77);
org.junit.Assert.assertNotNull(shortArray1);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray1), "[]");
org.junit.Assert.assertNotNull(shortArray2);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray2), "[]");
org.junit.Assert.assertNotNull(shortArray6);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray6), "[]");
org.junit.Assert.assertNotNull(shortArray7);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray7), "[]");
org.junit.Assert.assertNotNull(shortArray11);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray11), "[]");
org.junit.Assert.assertNotNull(shortArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray12), "[]");
org.junit.Assert.assertNotNull(shortArray15);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray15), "[]");
org.junit.Assert.assertNotNull(shortArray16);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray16), "[]");
org.junit.Assert.assertNotNull(shortArray20);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray20), "[]");
org.junit.Assert.assertNotNull(shortArray21);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray21), "[]");
org.junit.Assert.assertNotNull(shortArray24);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray24), "[]");
org.junit.Assert.assertNotNull(shortArray25);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray25), "[]");
org.junit.Assert.assertNotNull(shortArray31);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray31), "[]");
org.junit.Assert.assertNotNull(shortArray32);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray32), "[]");
org.junit.Assert.assertNotNull(shortArray35);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray35), "[]");
org.junit.Assert.assertNotNull(shortArray36);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray36), "[]");
org.junit.Assert.assertNotNull(shortArray42);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray42), "[]");
org.junit.Assert.assertNotNull(shortArray43);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray43), "[]");
org.junit.Assert.assertNotNull(shortArray46);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray46), "[]");
org.junit.Assert.assertNotNull(shortArray47);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray47), "[]");
org.junit.Assert.assertNotNull(shortArray52);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray52), "[]");
org.junit.Assert.assertNotNull(shortArray53);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray53), "[]");
org.junit.Assert.assertNotNull(shortArray56);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray56), "[]");
org.junit.Assert.assertNotNull(shortArray57);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray57), "[]");
org.junit.Assert.assertNotNull(shortArray61);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray61), "[]");
org.junit.Assert.assertNotNull(shortArray62);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray62), "[]");
org.junit.Assert.assertNotNull(shortArray65);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray65), "[]");
org.junit.Assert.assertNotNull(shortArray66);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray66), "[]");
org.junit.Assert.assertNotNull(shortArray73);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray73), "[]");
org.junit.Assert.assertNotNull(shortArray74);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray74), "[]");
org.junit.Assert.assertNotNull(shortArray77);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray77), "[]");
org.junit.Assert.assertNotNull(shortArray78);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray78), "[]");
}
@Test
public void test17543() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17543");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.badapples", indexReader7, (int) ' ', postingsEnum9, postingsEnum10);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17544() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17544");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Fields fields38 = null;
org.apache.lucene.index.Fields fields39 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader37, fields38, fields39, false);
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.Terms terms44 = null;
org.apache.lucene.index.Terms terms45 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader43, terms44, terms45, true);
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.badapples", postingsEnum49, postingsEnum50, true);
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.rules.RuleChain ruleChain56 = kuromojiAnalysisTests0.failureAndSuccessEvents;
java.nio.file.Path path57 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertPathHasBeenCleared(path57);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(ruleChain56);
}
@Test
public void test17545() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17545");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomRealisticUnicodeOfLengthBetween((int) 'a', 1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17546() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17546");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum37, postingsEnum38, false);
org.apache.lucene.index.IndexReader indexReader42 = null;
org.apache.lucene.index.IndexReader indexReader43 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderEquals("tests.badapples", indexReader42, indexReader43);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17547() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17547");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader17, (int) (short) -1, postingsEnum19, postingsEnum20);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests23 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests23.ruleChain;
kuromojiAnalysisTests23.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests23);
org.junit.rules.RuleChain ruleChain27 = kuromojiAnalysisTests23.failureAndSuccessEvents;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain27;
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.badapples", indexReader30, 0, postingsEnum32, postingsEnum33, true);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Terms terms38 = null;
org.apache.lucene.index.Terms terms39 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader37, terms38, terms39, false);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.junit.Assert.assertNotNull("<unknown>", (java.lang.Object) kuromojiAnalysisTests1);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.Fields fields46 = null;
org.apache.lucene.index.Fields fields47 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.assertFieldStatisticsEquals("", fields46, fields47);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain27);
}
@Test
public void test17548() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17548");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.monster", postingsEnum10, postingsEnum11, true);
org.junit.rules.RuleChain ruleChain14 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests16 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests16.ruleChain;
kuromojiAnalysisTests16.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests16);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests16.assertTermsEquals("random", indexReader21, terms22, terms23, false);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests16.failureAndSuccessEvents;
org.junit.runners.model.Statement statement27 = null;
org.junit.runner.Description description28 = null;
org.junit.runners.model.Statement statement29 = ruleChain26.apply(statement27, description28);
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain26;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests31 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader33 = null;
org.apache.lucene.index.Terms terms34 = null;
org.apache.lucene.index.Terms terms35 = null;
kuromojiAnalysisTests31.assertTermsEquals("", indexReader33, terms34, terms35, false);
kuromojiAnalysisTests31.ensureCheckIndexPassed();
kuromojiAnalysisTests31.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests31.ensureAllSearchContextsReleased();
java.lang.String str41 = kuromojiAnalysisTests31.getTestName();
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests31.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests44 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule45 = kuromojiAnalysisTests44.ruleChain;
kuromojiAnalysisTests44.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests44);
org.apache.lucene.index.IndexReader indexReader49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum52 = null;
kuromojiAnalysisTests44.assertPositionsSkippingEquals("tests.weekly", indexReader49, (int) (short) 1, postingsEnum51, postingsEnum52);
java.lang.String str54 = kuromojiAnalysisTests44.getTestName();
org.junit.rules.TestRule testRule55 = kuromojiAnalysisTests44.ruleChain;
org.junit.rules.RuleChain ruleChain56 = org.junit.rules.RuleChain.outerRule(testRule55);
org.junit.rules.RuleChain ruleChain57 = ruleChain42.around((org.junit.rules.TestRule) ruleChain56);
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain57;
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
kuromojiAnalysisTests1.resetCheckIndexStatus();
org.junit.Assert.assertNotNull("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.PostingsEnum postingsEnum63 = null;
org.apache.lucene.index.PostingsEnum postingsEnum64 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("random", postingsEnum63, postingsEnum64, true);
org.junit.Assert.assertNotNull(ruleChain14);
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(statement29);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "<unknown>" + "'", str41, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(testRule45);
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "<unknown>" + "'", str54, "<unknown>");
org.junit.Assert.assertNotNull(testRule55);
org.junit.Assert.assertNotNull(ruleChain56);
org.junit.Assert.assertNotNull(ruleChain57);
}
@Test
public void test17549() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17549");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) (-1));
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Terms terms9 = null;
org.apache.lucene.index.Terms terms10 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.awaitsfix", indexReader8, terms9, terms10, true);
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("random", postingsEnum14, postingsEnum15, false);
org.junit.rules.RuleChain ruleChain18 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests21 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.Terms terms24 = null;
org.apache.lucene.index.Terms terms25 = null;
kuromojiAnalysisTests21.assertTermsEquals("", indexReader23, terms24, terms25, false);
kuromojiAnalysisTests21.setUp();
kuromojiAnalysisTests21.ensureAllSearchContextsReleased();
char[] charArray32 = new char[] {};
char[] charArray33 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray32, charArray33);
char[] charArray35 = new char[] {};
char[] charArray36 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray35, charArray36);
org.junit.Assert.assertArrayEquals(charArray33, charArray36);
char[] charArray39 = new char[] {};
char[] charArray40 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray39, charArray40);
char[] charArray42 = new char[] {};
char[] charArray43 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray42, charArray43);
org.junit.Assert.assertArrayEquals(charArray40, charArray43);
org.junit.Assert.assertArrayEquals("random", charArray33, charArray40);
char[] charArray47 = new char[] {};
char[] charArray48 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray47, charArray48);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", charArray40, charArray48);
org.junit.Assert.assertNotSame("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests21, (java.lang.Object) charArray40);
org.junit.Assert.assertNotNull("random", (java.lang.Object) charArray40);
org.junit.Assert.assertNotEquals("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) "random");
org.apache.lucene.index.IndexReader indexReader55 = null;
org.apache.lucene.index.IndexReader indexReader56 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.assertStoredFieldsEquals("tests.nightly", indexReader55, indexReader56);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(ruleChain18);
org.junit.Assert.assertNotNull(charArray32);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray32), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray32), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray32), "[]");
org.junit.Assert.assertNotNull(charArray33);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray33), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray33), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray33), "[]");
org.junit.Assert.assertNotNull(charArray35);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray35), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray35), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray35), "[]");
org.junit.Assert.assertNotNull(charArray36);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray36), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray36), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray36), "[]");
org.junit.Assert.assertNotNull(charArray39);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray39), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray39), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray39), "[]");
org.junit.Assert.assertNotNull(charArray40);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray40), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray40), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray40), "[]");
org.junit.Assert.assertNotNull(charArray42);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray42), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray42), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray42), "[]");
org.junit.Assert.assertNotNull(charArray43);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray43), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray43), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray43), "[]");
org.junit.Assert.assertNotNull(charArray47);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray47), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray47), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray47), "[]");
org.junit.Assert.assertNotNull(charArray48);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray48), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray48), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray48), "[]");
}
@Test
public void test17550() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17550");
org.junit.Assert.assertNotEquals("tests.monster", (long) 4, (long) 3);
}
@Test
public void test17551() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17551");
short[] shortArray4 = new short[] { (byte) 0, (short) 100, (short) 10 };
short[] shortArray8 = new short[] { (byte) 0, (short) 100, (short) 10 };
short[] shortArray12 = new short[] { (byte) 0, (short) 100, (short) 10 };
short[] shortArray16 = new short[] { (byte) 0, (short) 100, (short) 10 };
short[][] shortArray17 = new short[][] { shortArray4, shortArray8, shortArray12, shortArray16 };
// The following exception was thrown during execution in test generation
try {
java.util.List<short[]> shortArrayList18 = org.elasticsearch.test.ESTestCase.randomSubsetOf((int) (short) -1, shortArray17);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: fromIndex(0) > toIndex(-1)");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(shortArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray4), "[0, 100, 10]");
org.junit.Assert.assertNotNull(shortArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray8), "[0, 100, 10]");
org.junit.Assert.assertNotNull(shortArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray12), "[0, 100, 10]");
org.junit.Assert.assertNotNull(shortArray16);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray16), "[0, 100, 10]");
org.junit.Assert.assertNotNull(shortArray17);
}
@Test
public void test17552() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17552");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Terms terms11 = null;
org.apache.lucene.index.Terms terms12 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader10, terms11, terms12, false);
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
kuromojiAnalysisTests1.resetCheckIndexStatus();
org.junit.Assert.assertNotNull("tests.badapples", (java.lang.Object) kuromojiAnalysisTests1);
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.Fields fields21 = null;
org.apache.lucene.index.Fields fields22 = null;
kuromojiAnalysisTests1.assertFieldsEquals("europarl.lines.txt.gz", indexReader20, fields21, fields22, false);
java.lang.Class<?> wildcardClass25 = kuromojiAnalysisTests1.getClass();
org.junit.Assert.assertNotNull(wildcardClass25);
}
@Test
public void test17553() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17553");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain3 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 1);
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.awaitsfix", postingsEnum7, postingsEnum8, false);
// The following exception was thrown during execution in test generation
try {
java.lang.String[] strArray11 = kuromojiAnalysisTests0.tmpPaths();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain3);
}
@Test
public void test17554() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17554");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests0);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, true);
org.junit.rules.RuleChain ruleChain17 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("hi!", indexReader19, (int) (short) 0, postingsEnum21, postingsEnum22);
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests0.tearDown();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService27 = kuromojiAnalysisTests0.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain17);
}
@Test
public void test17555() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17555");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum5 = null;
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.monster", postingsEnum5, postingsEnum6, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Fields fields14 = null;
org.apache.lucene.index.Fields fields15 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.maxfailures", indexReader13, fields14, fields15, true);
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain11);
}
@Test
public void test17556() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17556");
java.util.Set[][][][] setArray2 = new java.util.Set[0][][][];
@SuppressWarnings("unchecked")
java.util.Set<java.io.Serializable>[][][][] serializableSetArray3 = (java.util.Set<java.io.Serializable>[][][][]) setArray2;
java.util.Set<java.util.Set<java.io.Serializable>[][][]> serializableSetArraySet4 = org.apache.lucene.util.LuceneTestCase.asSet(serializableSetArray3);
java.util.Set<java.lang.Iterable<java.io.Serializable>[][][]> serializableIterableArraySet5 = org.apache.lucene.util.LuceneTestCase.asSet((java.lang.Iterable<java.io.Serializable>[][][][]) serializableSetArray3);
java.util.Set<java.lang.Iterable<java.io.Serializable>[][][]> serializableIterableArraySet6 = org.apache.lucene.util.LuceneTestCase.asSet((java.lang.Iterable<java.io.Serializable>[][][][]) serializableSetArray3);
org.junit.Assert.assertNotNull((java.lang.Object) serializableSetArray3);
java.io.Serializable[] serializableArray12 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet13 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray12);
java.io.Serializable[] serializableArray15 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet16 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray15);
java.io.Serializable[] serializableArray17 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet18 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray17);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray15, (java.lang.Object[]) serializableArray17);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray12, (java.lang.Object[]) serializableArray17);
java.io.Serializable[] serializableArray22 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet23 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray22);
java.io.Serializable[] serializableArray25 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet26 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray25);
java.io.Serializable[] serializableArray27 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet28 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray27);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray25, (java.lang.Object[]) serializableArray27);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray22, (java.lang.Object[]) serializableArray27);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray12, (java.lang.Object[]) serializableArray22);
org.junit.Assert.assertNotNull((java.lang.Object) serializableArray22);
org.junit.Assert.assertNotEquals((java.lang.Object) 2, (java.lang.Object) serializableArray22);
java.util.concurrent.ExecutorService[] executorServiceArray34 = new java.util.concurrent.ExecutorService[] {};
boolean boolean35 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray34);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray22, (java.lang.Object[]) executorServiceArray34);
org.junit.Assert.assertEquals("hi!", (java.lang.Object[]) serializableSetArray3, (java.lang.Object[]) executorServiceArray34);
org.junit.Assert.assertNotNull(setArray2);
org.junit.Assert.assertNotNull(serializableSetArray3);
org.junit.Assert.assertNotNull(serializableSetArraySet4);
org.junit.Assert.assertNotNull(serializableIterableArraySet5);
org.junit.Assert.assertNotNull(serializableIterableArraySet6);
org.junit.Assert.assertNotNull(serializableArray12);
org.junit.Assert.assertNotNull(serializableSet13);
org.junit.Assert.assertNotNull(serializableArray15);
org.junit.Assert.assertNotNull(serializableSet16);
org.junit.Assert.assertNotNull(serializableArray17);
org.junit.Assert.assertNotNull(serializableSet18);
org.junit.Assert.assertNotNull(serializableArray22);
org.junit.Assert.assertNotNull(serializableSet23);
org.junit.Assert.assertNotNull(serializableArray25);
org.junit.Assert.assertNotNull(serializableSet26);
org.junit.Assert.assertNotNull(serializableArray27);
org.junit.Assert.assertNotNull(serializableSet28);
org.junit.Assert.assertNotNull(executorServiceArray34);
org.junit.Assert.assertTrue("'" + boolean35 + "' != '" + true + "'", boolean35 == true);
}
@Test
public void test17557() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17557");
int[] intArray5 = new int[] {};
int[] intArray6 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray5, intArray6);
int[] intArray9 = new int[] {};
int[] intArray10 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray9, intArray10);
org.junit.Assert.assertArrayEquals(intArray6, intArray9);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray6, (java.lang.Object) 100.0d);
int[] intArray18 = new int[] {};
int[] intArray19 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray18, intArray19);
int[] intArray22 = new int[] {};
int[] intArray23 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray22, intArray23);
org.junit.Assert.assertArrayEquals(intArray19, intArray22);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray19, (java.lang.Object) 100.0d);
int[] intArray29 = new int[] {};
int[] intArray30 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray29, intArray30);
org.junit.Assert.assertArrayEquals("tests.nightly", intArray19, intArray29);
org.junit.Assert.assertArrayEquals("random", intArray6, intArray19);
int[] intArray36 = new int[] {};
int[] intArray37 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray36, intArray37);
int[] intArray40 = new int[] {};
int[] intArray41 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray40, intArray41);
org.junit.Assert.assertArrayEquals(intArray37, intArray40);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray37, (java.lang.Object) 100.0d);
org.junit.Assert.assertArrayEquals(intArray19, intArray37);
int[] intArray48 = new int[] {};
int[] intArray49 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray48, intArray49);
org.junit.Assert.assertArrayEquals("<unknown>", intArray19, intArray48);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests52 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests52.tearDown();
org.apache.lucene.index.IndexReader indexReader55 = null;
org.apache.lucene.index.Terms terms56 = null;
org.apache.lucene.index.Terms terms57 = null;
kuromojiAnalysisTests52.assertTermsEquals("tests.failfast", indexReader55, terms56, terms57, false);
org.apache.lucene.index.IndexReader indexReader61 = null;
org.apache.lucene.index.PostingsEnum postingsEnum63 = null;
org.apache.lucene.index.PostingsEnum postingsEnum64 = null;
kuromojiAnalysisTests52.assertDocsSkippingEquals("tests.nightly", indexReader61, (int) (byte) -1, postingsEnum63, postingsEnum64, false);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.PostingsEnum postingsEnum70 = null;
org.apache.lucene.index.PostingsEnum postingsEnum71 = null;
kuromojiAnalysisTests52.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader68, (int) (short) -1, postingsEnum70, postingsEnum71);
java.lang.String str73 = kuromojiAnalysisTests52.getTestName();
kuromojiAnalysisTests52.setUp();
org.junit.Assert.assertNotSame("random", (java.lang.Object) intArray48, (java.lang.Object) kuromojiAnalysisTests52);
kuromojiAnalysisTests52.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader78 = null;
org.apache.lucene.index.PostingsEnum postingsEnum80 = null;
org.apache.lucene.index.PostingsEnum postingsEnum81 = null;
kuromojiAnalysisTests52.assertDocsSkippingEquals("enwiki.random.lines.txt", indexReader78, (-1), postingsEnum80, postingsEnum81, false);
org.junit.Assert.assertNotNull(intArray5);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray5), "[]");
org.junit.Assert.assertNotNull(intArray6);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray6), "[]");
org.junit.Assert.assertNotNull(intArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray9), "[]");
org.junit.Assert.assertNotNull(intArray10);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray10), "[]");
org.junit.Assert.assertNotNull(intArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray18), "[]");
org.junit.Assert.assertNotNull(intArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray19), "[]");
org.junit.Assert.assertNotNull(intArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray22), "[]");
org.junit.Assert.assertNotNull(intArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray23), "[]");
org.junit.Assert.assertNotNull(intArray29);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray29), "[]");
org.junit.Assert.assertNotNull(intArray30);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray30), "[]");
org.junit.Assert.assertNotNull(intArray36);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray36), "[]");
org.junit.Assert.assertNotNull(intArray37);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray37), "[]");
org.junit.Assert.assertNotNull(intArray40);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray40), "[]");
org.junit.Assert.assertNotNull(intArray41);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray41), "[]");
org.junit.Assert.assertNotNull(intArray48);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray48), "[]");
org.junit.Assert.assertNotNull(intArray49);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray49), "[]");
org.junit.Assert.assertEquals("'" + str73 + "' != '" + "<unknown>" + "'", str73, "<unknown>");
}
@Test
public void test17558() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17558");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain9 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum11, postingsEnum12, true);
java.lang.Class<?> wildcardClass15 = kuromojiAnalysisTests0.getClass();
org.junit.Assert.assertNotNull(ruleChain9);
org.junit.Assert.assertNotNull(wildcardClass15);
}
@Test
public void test17559() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17559");
java.lang.String[][][][] strArray2 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray3 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray4 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray5 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray6 = new java.lang.String[][][][][] { strArray2, strArray3, strArray4, strArray5 };
java.lang.String[][][][] strArray7 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray8 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray9 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray10 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray11 = new java.lang.String[][][][][] { strArray7, strArray8, strArray9, strArray10 };
java.lang.String[][][][] strArray12 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray13 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray14 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray15 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray16 = new java.lang.String[][][][][] { strArray12, strArray13, strArray14, strArray15 };
java.lang.String[][][][] strArray17 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray18 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray19 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray20 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray21 = new java.lang.String[][][][][] { strArray17, strArray18, strArray19, strArray20 };
java.lang.String[][][][] strArray22 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray23 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray24 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray25 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray26 = new java.lang.String[][][][][] { strArray22, strArray23, strArray24, strArray25 };
java.lang.String[][][][] strArray27 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray28 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray29 = new java.lang.String[][][][] {};
java.lang.String[][][][] strArray30 = new java.lang.String[][][][] {};
java.lang.String[][][][][] strArray31 = new java.lang.String[][][][][] { strArray27, strArray28, strArray29, strArray30 };
java.lang.String[][][][][][] strArray32 = new java.lang.String[][][][][][] { strArray6, strArray11, strArray16, strArray21, strArray26, strArray31 };
java.util.List<java.lang.String[][][][][]> strArrayList33 = org.elasticsearch.test.ESTestCase.randomSubsetOf(0, strArray32);
java.util.Set<java.lang.String[][][][][]> strArraySet34 = org.apache.lucene.util.LuceneTestCase.asSet(strArray32);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests35 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Terms terms38 = null;
org.apache.lucene.index.Terms terms39 = null;
kuromojiAnalysisTests35.assertTermsEquals("", indexReader37, terms38, terms39, false);
kuromojiAnalysisTests35.setUp();
kuromojiAnalysisTests35.resetCheckIndexStatus();
kuromojiAnalysisTests35.setIndexWriterMaxDocs((int) (byte) 10);
kuromojiAnalysisTests35.setUp();
org.junit.Assert.assertNotEquals("tests.failfast", (java.lang.Object) strArray32, (java.lang.Object) kuromojiAnalysisTests35);
org.apache.lucene.index.TermsEnum termsEnum49 = null;
org.apache.lucene.index.TermsEnum termsEnum50 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests35.assertTermStatsEquals("tests.awaitsfix", termsEnum49, termsEnum50);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(strArray2);
org.junit.Assert.assertNotNull(strArray3);
org.junit.Assert.assertNotNull(strArray4);
org.junit.Assert.assertNotNull(strArray5);
org.junit.Assert.assertNotNull(strArray6);
org.junit.Assert.assertNotNull(strArray7);
org.junit.Assert.assertNotNull(strArray8);
org.junit.Assert.assertNotNull(strArray9);
org.junit.Assert.assertNotNull(strArray10);
org.junit.Assert.assertNotNull(strArray11);
org.junit.Assert.assertNotNull(strArray12);
org.junit.Assert.assertNotNull(strArray13);
org.junit.Assert.assertNotNull(strArray14);
org.junit.Assert.assertNotNull(strArray15);
org.junit.Assert.assertNotNull(strArray16);
org.junit.Assert.assertNotNull(strArray17);
org.junit.Assert.assertNotNull(strArray18);
org.junit.Assert.assertNotNull(strArray19);
org.junit.Assert.assertNotNull(strArray20);
org.junit.Assert.assertNotNull(strArray21);
org.junit.Assert.assertNotNull(strArray22);
org.junit.Assert.assertNotNull(strArray23);
org.junit.Assert.assertNotNull(strArray24);
org.junit.Assert.assertNotNull(strArray25);
org.junit.Assert.assertNotNull(strArray26);
org.junit.Assert.assertNotNull(strArray27);
org.junit.Assert.assertNotNull(strArray28);
org.junit.Assert.assertNotNull(strArray29);
org.junit.Assert.assertNotNull(strArray30);
org.junit.Assert.assertNotNull(strArray31);
org.junit.Assert.assertNotNull(strArray32);
org.junit.Assert.assertNotNull(strArrayList33);
org.junit.Assert.assertNotNull(strArraySet34);
}
@Test
public void test17560() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17560");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.ensureCleanedUp();
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.awaitsfix", postingsEnum13, postingsEnum14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests1.ruleChain;
org.junit.rules.TestRule testRule18 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests1.assertTermsEquals("hi!", indexReader21, terms22, terms23, false);
kuromojiAnalysisTests1.ensureCleanedUp();
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertNotNull(testRule18);
}
@Test
public void test17561() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17561");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomAsciiOfLengthBetween(5, 0);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17562() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17562");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests0.ruleChain;
java.lang.String str18 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.RuleChain ruleChain19 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests20 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests20.tearDown();
kuromojiAnalysisTests20.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests20.ensureCleanedUp();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests20.ruleChain;
kuromojiAnalysisTests20.assertPathHasBeenCleared("europarl.lines.txt.gz");
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain19, (java.lang.Object) kuromojiAnalysisTests20);
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests20);
org.junit.rules.RuleChain ruleChain29 = kuromojiAnalysisTests20.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests20.assertTermsEquals("enwiki.random.lines.txt", indexReader31, terms32, terms33, false);
kuromojiAnalysisTests20.assertPathHasBeenCleared("tests.nightly");
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "<unknown>" + "'", str18, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain29);
}
@Test
public void test17563() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17563");
java.io.Serializable[] serializableArray6 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet7 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray6);
java.io.Serializable[] serializableArray9 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet10 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray9);
java.io.Serializable[] serializableArray11 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet12 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray11);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray9, (java.lang.Object[]) serializableArray11);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray6, (java.lang.Object[]) serializableArray11);
java.io.Serializable[] serializableArray16 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet17 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray16);
java.io.Serializable[] serializableArray19 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet20 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray19);
java.io.Serializable[] serializableArray21 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet22 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray21);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray19, (java.lang.Object[]) serializableArray21);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray16, (java.lang.Object[]) serializableArray21);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray6, (java.lang.Object[]) serializableArray16);
java.util.concurrent.ExecutorService[] executorServiceArray26 = new java.util.concurrent.ExecutorService[] {};
boolean boolean27 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray26);
org.junit.Assert.assertEquals("tests.slow", (java.lang.Object[]) serializableArray6, (java.lang.Object[]) executorServiceArray26);
boolean boolean29 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray26);
org.junit.Assert.assertNotNull("tests.failfast", (java.lang.Object) executorServiceArray26);
boolean boolean31 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray26);
org.elasticsearch.test.ESTestCase[][] eSTestCaseArray32 = new org.elasticsearch.test.ESTestCase[][] {};
java.util.Set<org.elasticsearch.test.ESTestCase[]> eSTestCaseArraySet33 = org.apache.lucene.util.LuceneTestCase.asSet(eSTestCaseArray32);
java.util.Set<org.elasticsearch.test.ESTestCase[]> eSTestCaseArraySet34 = org.apache.lucene.util.LuceneTestCase.asSet(eSTestCaseArray32);
org.junit.Assert.assertEquals("", (java.lang.Object[]) executorServiceArray26, (java.lang.Object[]) eSTestCaseArray32);
java.io.Serializable[] serializableArray38 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet39 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray38);
java.io.Serializable[] serializableArray40 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet41 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray40);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray38, (java.lang.Object[]) serializableArray40);
java.util.concurrent.ExecutorService[] executorServiceArray43 = new java.util.concurrent.ExecutorService[] {};
boolean boolean44 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray43);
boolean boolean45 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray43);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray38, (java.lang.Object[]) executorServiceArray43);
org.junit.Assert.assertNotNull("tests.nightly", (java.lang.Object) executorServiceArray43);
org.junit.Assert.assertEquals("tests.slow", (java.lang.Object[]) eSTestCaseArray32, (java.lang.Object[]) executorServiceArray43);
org.junit.Assert.assertNotNull(serializableArray6);
org.junit.Assert.assertNotNull(serializableSet7);
org.junit.Assert.assertNotNull(serializableArray9);
org.junit.Assert.assertNotNull(serializableSet10);
org.junit.Assert.assertNotNull(serializableArray11);
org.junit.Assert.assertNotNull(serializableSet12);
org.junit.Assert.assertNotNull(serializableArray16);
org.junit.Assert.assertNotNull(serializableSet17);
org.junit.Assert.assertNotNull(serializableArray19);
org.junit.Assert.assertNotNull(serializableSet20);
org.junit.Assert.assertNotNull(serializableArray21);
org.junit.Assert.assertNotNull(serializableSet22);
org.junit.Assert.assertNotNull(executorServiceArray26);
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + true + "'", boolean29 == true);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + true + "'", boolean31 == true);
org.junit.Assert.assertNotNull(eSTestCaseArray32);
org.junit.Assert.assertNotNull(eSTestCaseArraySet33);
org.junit.Assert.assertNotNull(eSTestCaseArraySet34);
org.junit.Assert.assertNotNull(serializableArray38);
org.junit.Assert.assertNotNull(serializableSet39);
org.junit.Assert.assertNotNull(serializableArray40);
org.junit.Assert.assertNotNull(serializableSet41);
org.junit.Assert.assertNotNull(executorServiceArray43);
org.junit.Assert.assertTrue("'" + boolean44 + "' != '" + true + "'", boolean44 == true);
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + true + "'", boolean45 == true);
}
@Test
public void test17564() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17564");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule4 = kuromojiAnalysisTests3.ruleChain;
kuromojiAnalysisTests3.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests3);
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Terms terms9 = null;
org.apache.lucene.index.Terms terms10 = null;
kuromojiAnalysisTests3.assertTermsEquals("random", indexReader8, terms9, terms10, false);
org.junit.rules.RuleChain ruleChain13 = kuromojiAnalysisTests3.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain14 = kuromojiAnalysisTests3.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests16 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests16.ruleChain;
kuromojiAnalysisTests16.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests16);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests16.assertTermsEquals("random", indexReader21, terms22, terms23, false);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests16.failureAndSuccessEvents;
org.junit.runners.model.Statement statement27 = null;
org.junit.runner.Description description28 = null;
org.junit.runners.model.Statement statement29 = ruleChain26.apply(statement27, description28);
kuromojiAnalysisTests3.failureAndSuccessEvents = ruleChain26;
org.junit.rules.RuleChain ruleChain31 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain26);
org.junit.Assert.assertNotNull("random", (java.lang.Object) ruleChain26);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain26;
int[] intArray37 = new int[] {};
int[] intArray38 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray37, intArray38);
int[] intArray41 = new int[] {};
int[] intArray42 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray41, intArray42);
org.junit.Assert.assertArrayEquals(intArray38, intArray41);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray38, (java.lang.Object) 100.0d);
int[] intArray50 = new int[] {};
int[] intArray51 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray50, intArray51);
int[] intArray54 = new int[] {};
int[] intArray55 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray54, intArray55);
org.junit.Assert.assertArrayEquals(intArray51, intArray54);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray51, (java.lang.Object) 100.0d);
int[] intArray63 = new int[] {};
int[] intArray64 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray63, intArray64);
int[] intArray67 = new int[] {};
int[] intArray68 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray67, intArray68);
org.junit.Assert.assertArrayEquals(intArray64, intArray67);
org.junit.Assert.assertNotEquals("random", (java.lang.Object) intArray64, (java.lang.Object) 100.0d);
int[] intArray74 = new int[] {};
int[] intArray75 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray74, intArray75);
org.junit.Assert.assertArrayEquals("tests.nightly", intArray64, intArray74);
org.junit.Assert.assertArrayEquals("random", intArray51, intArray64);
org.junit.Assert.assertArrayEquals("tests.nightly", intArray38, intArray51);
int[] intArray81 = new int[] {};
int[] intArray82 = new int[] {};
org.junit.Assert.assertArrayEquals("", intArray81, intArray82);
org.junit.Assert.assertArrayEquals(intArray51, intArray82);
org.junit.Assert.assertNotEquals("enwiki.random.lines.txt", (java.lang.Object) ruleChain26, (java.lang.Object) intArray82);
org.junit.Assert.assertNotNull(testRule4);
org.junit.Assert.assertNotNull(ruleChain13);
org.junit.Assert.assertNotNull(ruleChain14);
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(statement29);
org.junit.Assert.assertNotNull(ruleChain31);
org.junit.Assert.assertNotNull(intArray37);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray37), "[]");
org.junit.Assert.assertNotNull(intArray38);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray38), "[]");
org.junit.Assert.assertNotNull(intArray41);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray41), "[]");
org.junit.Assert.assertNotNull(intArray42);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray42), "[]");
org.junit.Assert.assertNotNull(intArray50);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray50), "[]");
org.junit.Assert.assertNotNull(intArray51);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray51), "[]");
org.junit.Assert.assertNotNull(intArray54);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray54), "[]");
org.junit.Assert.assertNotNull(intArray55);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray55), "[]");
org.junit.Assert.assertNotNull(intArray63);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray63), "[]");
org.junit.Assert.assertNotNull(intArray64);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray64), "[]");
org.junit.Assert.assertNotNull(intArray67);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray67), "[]");
org.junit.Assert.assertNotNull(intArray68);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray68), "[]");
org.junit.Assert.assertNotNull(intArray74);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray74), "[]");
org.junit.Assert.assertNotNull(intArray75);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray75), "[]");
org.junit.Assert.assertNotNull(intArray81);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray81), "[]");
org.junit.Assert.assertNotNull(intArray82);
org.junit.Assert.assertEquals(java.util.Arrays.toString(intArray82), "[]");
}
@Test
public void test17565() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17565");
org.junit.Assert.assertEquals((long) (short) 10, (long) (byte) 10);
}
@Test
public void test17566() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17566");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.monster", postingsEnum10, postingsEnum11, true);
java.lang.String str14 = kuromojiAnalysisTests1.getTestName();
org.junit.rules.RuleChain ruleChain15 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests17 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule18 = kuromojiAnalysisTests17.ruleChain;
kuromojiAnalysisTests17.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests17);
org.apache.lucene.index.IndexReader indexReader22 = null;
org.apache.lucene.index.Terms terms23 = null;
org.apache.lucene.index.Terms terms24 = null;
kuromojiAnalysisTests17.assertTermsEquals("random", indexReader22, terms23, terms24, false);
org.junit.rules.RuleChain ruleChain27 = kuromojiAnalysisTests17.failureAndSuccessEvents;
org.junit.runners.model.Statement statement28 = null;
org.junit.runner.Description description29 = null;
org.junit.runners.model.Statement statement30 = ruleChain27.apply(statement28, description29);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests32 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule33 = kuromojiAnalysisTests32.ruleChain;
kuromojiAnalysisTests32.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests32);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Terms terms38 = null;
org.apache.lucene.index.Terms terms39 = null;
kuromojiAnalysisTests32.assertTermsEquals("random", indexReader37, terms38, terms39, false);
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests32.failureAndSuccessEvents;
org.junit.runners.model.Statement statement43 = null;
org.junit.runner.Description description44 = null;
org.junit.runners.model.Statement statement45 = ruleChain42.apply(statement43, description44);
org.junit.runner.Description description46 = null;
org.junit.runners.model.Statement statement47 = ruleChain27.apply(statement45, description46);
org.junit.runner.Description description48 = null;
org.junit.runners.model.Statement statement49 = ruleChain15.apply(statement45, description48);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests50 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests50.tearDown();
org.apache.lucene.index.IndexReader indexReader53 = null;
org.apache.lucene.index.Terms terms54 = null;
org.apache.lucene.index.Terms terms55 = null;
kuromojiAnalysisTests50.assertTermsEquals("tests.failfast", indexReader53, terms54, terms55, false);
org.apache.lucene.index.IndexReader indexReader59 = null;
org.apache.lucene.index.PostingsEnum postingsEnum61 = null;
org.apache.lucene.index.PostingsEnum postingsEnum62 = null;
kuromojiAnalysisTests50.assertDocsSkippingEquals("tests.nightly", indexReader59, (int) (byte) -1, postingsEnum61, postingsEnum62, false);
org.apache.lucene.index.IndexReader indexReader66 = null;
org.apache.lucene.index.PostingsEnum postingsEnum68 = null;
org.apache.lucene.index.PostingsEnum postingsEnum69 = null;
kuromojiAnalysisTests50.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader66, (int) (short) -1, postingsEnum68, postingsEnum69);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests72 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule73 = kuromojiAnalysisTests72.ruleChain;
kuromojiAnalysisTests72.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests72);
org.junit.rules.RuleChain ruleChain76 = kuromojiAnalysisTests72.failureAndSuccessEvents;
kuromojiAnalysisTests50.failureAndSuccessEvents = ruleChain76;
org.apache.lucene.index.IndexReader indexReader79 = null;
org.apache.lucene.index.PostingsEnum postingsEnum81 = null;
org.apache.lucene.index.PostingsEnum postingsEnum82 = null;
kuromojiAnalysisTests50.assertDocsSkippingEquals("tests.badapples", indexReader79, 0, postingsEnum81, postingsEnum82, true);
kuromojiAnalysisTests50.resetCheckIndexStatus();
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain15, (java.lang.Object) kuromojiAnalysisTests50);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests87 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule88 = kuromojiAnalysisTests87.ruleChain;
org.junit.rules.RuleChain ruleChain89 = org.junit.rules.RuleChain.outerRule(testRule88);
org.junit.rules.RuleChain ruleChain90 = ruleChain15.around(testRule88);
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain90;
org.apache.lucene.index.PostingsEnum postingsEnum93 = null;
org.apache.lucene.index.PostingsEnum postingsEnum94 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.slow", postingsEnum93, postingsEnum94, true);
org.junit.Assert.assertNull("hi!", (java.lang.Object) postingsEnum93);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "<unknown>" + "'", str14, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule18);
org.junit.Assert.assertNotNull(ruleChain27);
org.junit.Assert.assertNotNull(statement30);
org.junit.Assert.assertNotNull(testRule33);
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(statement45);
org.junit.Assert.assertNotNull(statement47);
org.junit.Assert.assertNotNull(statement49);
org.junit.Assert.assertNotNull(testRule73);
org.junit.Assert.assertNotNull(ruleChain76);
org.junit.Assert.assertNotNull(testRule88);
org.junit.Assert.assertNotNull(ruleChain89);
org.junit.Assert.assertNotNull(ruleChain90);
}
@Test
public void test17567() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17567");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.Fields fields12 = null;
org.apache.lucene.index.Fields fields13 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.monster", indexReader11, fields12, fields13, false);
org.junit.rules.RuleChain ruleChain16 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.Terms terms18 = null;
org.apache.lucene.index.Terms terms19 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermsStatisticsEquals("tests.failfast", terms18, terms19);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain16);
}
@Test
public void test17568() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17568");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.TestRule testRule10 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("hi!");
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Fields fields15 = null;
org.apache.lucene.index.Fields fields16 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.badapples", indexReader14, fields15, fields16, true);
org.junit.Assert.assertNotNull(testRule10);
}
@Test
public void test17569() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17569");
byte[] byteArray3 = new byte[] {};
byte[] byteArray4 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray3, byteArray4);
byte[] byteArray8 = new byte[] {};
byte[] byteArray9 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray8, byteArray9);
byte[] byteArray12 = new byte[] {};
byte[] byteArray13 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray12, byteArray13);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray8, byteArray12);
byte[] byteArray18 = new byte[] {};
byte[] byteArray19 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray18, byteArray19);
byte[] byteArray22 = new byte[] {};
byte[] byteArray23 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray22, byteArray23);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray18, byteArray22);
org.junit.Assert.assertArrayEquals(byteArray12, byteArray18);
org.junit.Assert.assertArrayEquals("", byteArray3, byteArray12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests28 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests28.tearDown();
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests28.assertTermsEquals("tests.failfast", indexReader31, terms32, terms33, false);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests28.assertDocsSkippingEquals("tests.nightly", indexReader37, (int) (byte) -1, postingsEnum39, postingsEnum40, false);
org.junit.rules.RuleChain ruleChain43 = kuromojiAnalysisTests28.failureAndSuccessEvents;
kuromojiAnalysisTests28.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests46 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule47 = kuromojiAnalysisTests46.ruleChain;
kuromojiAnalysisTests46.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests46);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests46.failureAndSuccessEvents;
kuromojiAnalysisTests46.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests28, (java.lang.Object) kuromojiAnalysisTests46);
org.junit.Assert.assertNotEquals("tests.maxfailures", (java.lang.Object) byteArray12, (java.lang.Object) kuromojiAnalysisTests46);
kuromojiAnalysisTests46.setUp();
kuromojiAnalysisTests46.setIndexWriterMaxDocs(3);
kuromojiAnalysisTests46.tearDown();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService58 = kuromojiAnalysisTests46.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(byteArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray3), "[]");
org.junit.Assert.assertNotNull(byteArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray4), "[]");
org.junit.Assert.assertNotNull(byteArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray8), "[]");
org.junit.Assert.assertNotNull(byteArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray9), "[]");
org.junit.Assert.assertNotNull(byteArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray12), "[]");
org.junit.Assert.assertNotNull(byteArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray13), "[]");
org.junit.Assert.assertNotNull(byteArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray18), "[]");
org.junit.Assert.assertNotNull(byteArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray19), "[]");
org.junit.Assert.assertNotNull(byteArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray22), "[]");
org.junit.Assert.assertNotNull(byteArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray23), "[]");
org.junit.Assert.assertNotNull(ruleChain43);
org.junit.Assert.assertNotNull(testRule47);
org.junit.Assert.assertNotNull(ruleChain50);
}
@Test
public void test17570() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17570");
short[][][][] shortArray1 = new short[][][][] {};
java.util.Set<short[][][]> shortArraySet2 = org.apache.lucene.util.LuceneTestCase.asSet(shortArray1);
java.util.concurrent.ExecutorService[] executorServiceArray3 = new java.util.concurrent.ExecutorService[] {};
boolean boolean4 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray3);
java.io.Serializable[] serializableArray6 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet7 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray6);
java.io.Serializable[] serializableArray9 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet10 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray9);
java.io.Serializable[] serializableArray12 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet13 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray12);
java.io.Serializable[] serializableArray14 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet15 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray14);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray12, (java.lang.Object[]) serializableArray14);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray9, (java.lang.Object[]) serializableArray14);
org.junit.Assert.assertEquals("tests.nightly", (java.lang.Object[]) serializableArray6, (java.lang.Object[]) serializableArray14);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) executorServiceArray3, (java.lang.Object[]) serializableArray6);
boolean boolean20 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray3);
boolean boolean21 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray3);
org.junit.Assert.assertEquals((java.lang.Object[]) shortArray1, (java.lang.Object[]) executorServiceArray3);
// The following exception was thrown during execution in test generation
try {
java.util.List<short[][][]> shortArrayList23 = org.elasticsearch.test.ESTestCase.randomSubsetOf((int) '#', shortArray1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Can't pick 35 random objects from a list of 0 objects");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(shortArray1);
org.junit.Assert.assertNotNull(shortArraySet2);
org.junit.Assert.assertNotNull(executorServiceArray3);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
org.junit.Assert.assertNotNull(serializableArray6);
org.junit.Assert.assertNotNull(serializableSet7);
org.junit.Assert.assertNotNull(serializableArray9);
org.junit.Assert.assertNotNull(serializableSet10);
org.junit.Assert.assertNotNull(serializableArray12);
org.junit.Assert.assertNotNull(serializableSet13);
org.junit.Assert.assertNotNull(serializableArray14);
org.junit.Assert.assertNotNull(serializableSet15);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + true + "'", boolean20 == true);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
}
@Test
public void test17571() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17571");
java.util.Locale locale2 = org.apache.lucene.util.LuceneTestCase.localeForName("enwiki.random.lines.txt");
java.lang.Class<?> wildcardClass3 = locale2.getClass();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests4 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests4.tearDown();
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.Fields fields8 = null;
org.apache.lucene.index.Fields fields9 = null;
kuromojiAnalysisTests4.assertFieldsEquals("enwiki.random.lines.txt", indexReader7, fields8, fields9, true);
kuromojiAnalysisTests4.setUp();
kuromojiAnalysisTests4.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.Fields fields17 = null;
org.apache.lucene.index.Fields fields18 = null;
kuromojiAnalysisTests4.assertFieldsEquals("enwiki.random.lines.txt", indexReader16, fields17, fields18, false);
java.lang.String str21 = kuromojiAnalysisTests4.getTestName();
kuromojiAnalysisTests4.ensureAllSearchContextsReleased();
kuromojiAnalysisTests4.setUp();
kuromojiAnalysisTests4.ensureCleanedUp();
kuromojiAnalysisTests4.resetCheckIndexStatus();
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests4.failureAndSuccessEvents;
org.junit.Assert.assertNotEquals("tests.failfast", (java.lang.Object) locale2, (java.lang.Object) ruleChain26);
org.junit.Assert.assertNotNull(locale2);
org.junit.Assert.assertEquals(locale2.toString(), "enwiki.random.lines.txt");
org.junit.Assert.assertNotNull(wildcardClass3);
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "<unknown>" + "'", str21, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17572() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17572");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.junit.Assert.assertNotSame("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) "");
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.nightly", postingsEnum6, postingsEnum7, true);
org.junit.rules.RuleChain ruleChain10 = kuromojiAnalysisTests1.failureAndSuccessEvents;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.maxfailures", postingsEnum13, postingsEnum14, false);
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.Fields fields19 = null;
org.apache.lucene.index.Fields fields20 = null;
kuromojiAnalysisTests1.assertFieldsEquals("tests.nightly", indexReader18, fields19, fields20, false);
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.IndexReader indexReader25 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.assertDocValuesEquals("europarl.lines.txt.gz", indexReader24, indexReader25);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain10);
}
@Test
public void test17573() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17573");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomAsciiOfLengthBetween((int) (byte) -1, 5);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17574() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17574");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.monster", postingsEnum9, postingsEnum10, true);
kuromojiAnalysisTests0.ensureCleanedUp();
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.failfast", postingsEnum15, postingsEnum16, true);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.monster", indexReader20, 3, postingsEnum22, postingsEnum23);
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.IndexReader indexReader27 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderEquals("enwiki.random.lines.txt", indexReader26, indexReader27);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17575() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17575");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.TermsEnum termsEnum10 = null;
org.apache.lucene.index.TermsEnum termsEnum11 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermStatsEquals("", termsEnum10, termsEnum11);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17576() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17576");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader16, 1, postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests25 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule26 = kuromojiAnalysisTests25.ruleChain;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.junit.rules.RuleChain ruleChain29 = org.junit.rules.RuleChain.outerRule(testRule26);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests30 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule31 = kuromojiAnalysisTests30.ruleChain;
org.junit.rules.RuleChain ruleChain32 = org.junit.rules.RuleChain.outerRule(testRule31);
org.junit.rules.RuleChain ruleChain33 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain32);
org.junit.rules.RuleChain ruleChain34 = ruleChain29.around((org.junit.rules.TestRule) ruleChain33);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain33;
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader38 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
org.apache.lucene.index.PostingsEnum postingsEnum41 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader38, (int) (short) 1, postingsEnum40, postingsEnum41, true);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testBaseFormFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule26);
org.junit.Assert.assertNotNull(ruleChain29);
org.junit.Assert.assertNotNull(testRule31);
org.junit.Assert.assertNotNull(ruleChain32);
org.junit.Assert.assertNotNull(ruleChain33);
org.junit.Assert.assertNotNull(ruleChain34);
}
@Test
public void test17577() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17577");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.awaitsfix", indexReader6, 2, postingsEnum8, postingsEnum9, true);
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum13, postingsEnum14, true);
java.io.Reader reader17 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str18 = kuromojiAnalysisTests0.readFully(reader17);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17578() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17578");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
kuromojiAnalysisTests0.setUp();
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("hi!", indexReader17, 1, postingsEnum19, postingsEnum20);
}
@Test
public void test17579() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17579");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader17, (int) (short) -1, postingsEnum19, postingsEnum20);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests23 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests23.ruleChain;
kuromojiAnalysisTests23.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests23);
org.junit.rules.RuleChain ruleChain27 = kuromojiAnalysisTests23.failureAndSuccessEvents;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain27;
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.badapples", indexReader30, 0, postingsEnum32, postingsEnum33, true);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.junit.rules.TestRule testRule37 = kuromojiAnalysisTests1.ruleChain;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests38 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule39 = kuromojiAnalysisTests38.ruleChain;
kuromojiAnalysisTests38.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests38.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
kuromojiAnalysisTests38.assertDocsEnumEquals("<unknown>", postingsEnum43, postingsEnum44, true);
kuromojiAnalysisTests38.ensureAllSearchContextsReleased();
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
kuromojiAnalysisTests38.assertDocsEnumEquals("", postingsEnum49, postingsEnum50, false);
kuromojiAnalysisTests38.ensureCleanedUp();
org.junit.Assert.assertNotSame("hi!", (java.lang.Object) testRule37, (java.lang.Object) kuromojiAnalysisTests38);
org.apache.lucene.index.IndexReader indexReader56 = null;
org.apache.lucene.index.PostingsEnum postingsEnum58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum59 = null;
kuromojiAnalysisTests38.assertDocsSkippingEquals("", indexReader56, 10, postingsEnum58, postingsEnum59, false);
java.nio.file.Path path62 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests38.assertPathHasBeenCleared(path62);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain27);
org.junit.Assert.assertNotNull(testRule37);
org.junit.Assert.assertNotNull(testRule39);
}
@Test
public void test17580() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17580");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 0);
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.slow");
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.junit.rules.TestRule testRule35 = kuromojiAnalysisTests0.ruleChain;
java.lang.String str36 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.TermsEnum termsEnum38 = null;
org.apache.lucene.index.TermsEnum termsEnum39 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermStatsEquals("hi!", termsEnum38, termsEnum39);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(testRule35);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "<unknown>" + "'", str36, "<unknown>");
}
@Test
public void test17581() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17581");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("<unknown>", postingsEnum6, postingsEnum7, true);
java.lang.String str10 = kuromojiAnalysisTests1.getTestName();
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader13, (-1), postingsEnum15, postingsEnum16, false);
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests1.ruleChain;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests21 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule22 = kuromojiAnalysisTests21.ruleChain;
kuromojiAnalysisTests21.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests21);
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.Terms terms27 = null;
org.apache.lucene.index.Terms terms28 = null;
kuromojiAnalysisTests21.assertTermsEquals("random", indexReader26, terms27, terms28, false);
org.junit.rules.RuleChain ruleChain31 = kuromojiAnalysisTests21.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader33 = null;
org.apache.lucene.index.Terms terms34 = null;
org.apache.lucene.index.Terms terms35 = null;
kuromojiAnalysisTests21.assertTermsEquals("europarl.lines.txt.gz", indexReader33, terms34, terms35, false);
kuromojiAnalysisTests21.resetCheckIndexStatus();
kuromojiAnalysisTests21.ensureCheckIndexPassed();
kuromojiAnalysisTests21.tearDown();
java.lang.String str41 = kuromojiAnalysisTests21.getTestName();
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.Fields fields44 = null;
org.apache.lucene.index.Fields fields45 = null;
kuromojiAnalysisTests21.assertFieldsEquals("tests.slow", indexReader43, fields44, fields45, true);
org.apache.lucene.index.IndexReader indexReader49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum52 = null;
kuromojiAnalysisTests21.assertDocsSkippingEquals("tests.badapples", indexReader49, 0, postingsEnum51, postingsEnum52, true);
org.junit.rules.TestRule testRule55 = kuromojiAnalysisTests21.ruleChain;
java.lang.Object obj56 = null;
org.junit.Assert.assertNotEquals((java.lang.Object) testRule55, obj56);
org.junit.Assert.assertNotEquals("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1, obj56);
org.apache.lucene.index.IndexReader indexReader60 = null;
org.apache.lucene.index.PostingsEnum postingsEnum62 = null;
org.apache.lucene.index.PostingsEnum postingsEnum63 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("", indexReader60, (int) '4', postingsEnum62, postingsEnum63);
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "<unknown>" + "'", str10, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain11);
org.junit.Assert.assertNotNull(testRule19);
org.junit.Assert.assertNotNull(testRule22);
org.junit.Assert.assertNotNull(ruleChain31);
org.junit.Assert.assertEquals("'" + str41 + "' != '" + "<unknown>" + "'", str41, "<unknown>");
org.junit.Assert.assertNotNull(testRule55);
}
@Test
public void test17582() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17582");
java.io.Serializable[] serializableArray4 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet5 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray4);
java.io.Serializable[] serializableArray7 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet8 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray7);
java.io.Serializable[] serializableArray9 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet10 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray9);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray7, (java.lang.Object[]) serializableArray9);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) serializableArray9);
java.io.Serializable[] serializableArray14 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet15 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray14);
java.io.Serializable[] serializableArray17 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet18 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray17);
java.io.Serializable[] serializableArray19 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet20 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray19);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray17, (java.lang.Object[]) serializableArray19);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray14, (java.lang.Object[]) serializableArray19);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray4, (java.lang.Object[]) serializableArray14);
java.io.Serializable[] serializableArray26 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet27 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray26);
java.io.Serializable[] serializableArray29 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet30 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray29);
java.io.Serializable[] serializableArray31 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet32 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray31);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray29, (java.lang.Object[]) serializableArray31);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray26, (java.lang.Object[]) serializableArray31);
java.io.Serializable[] serializableArray36 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet37 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray36);
java.io.Serializable[] serializableArray39 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet40 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray39);
java.io.Serializable[] serializableArray41 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet42 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray41);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray39, (java.lang.Object[]) serializableArray41);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray41);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray26, (java.lang.Object[]) serializableArray36);
java.io.Serializable[] serializableArray47 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet48 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray47);
java.io.Serializable[] serializableArray49 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet50 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray49);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray47, (java.lang.Object[]) serializableArray49);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray26, (java.lang.Object[]) serializableArray47);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray14, (java.lang.Object[]) serializableArray26);
java.io.Serializable[] serializableArray55 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet56 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray55);
java.io.Serializable[] serializableArray57 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet58 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray57);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray55, (java.lang.Object[]) serializableArray57);
java.util.concurrent.ExecutorService[] executorServiceArray60 = new java.util.concurrent.ExecutorService[] {};
boolean boolean61 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray60);
boolean boolean62 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray60);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray55, (java.lang.Object[]) executorServiceArray60);
boolean boolean64 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray60);
boolean boolean65 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray60);
org.apache.lucene.search.QueryCachingPolicy[] queryCachingPolicyArray67 = new org.apache.lucene.search.QueryCachingPolicy[] {};
java.util.List<org.apache.lucene.search.QueryCachingPolicy> queryCachingPolicyList68 = org.elasticsearch.test.ESTestCase.randomSubsetOf((int) (short) 0, queryCachingPolicyArray67);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) executorServiceArray60, (java.lang.Object[]) queryCachingPolicyArray67);
org.junit.Assert.assertEquals("tests.failfast", (java.lang.Object[]) serializableArray26, (java.lang.Object[]) executorServiceArray60);
org.junit.Assert.assertNotNull(serializableArray4);
org.junit.Assert.assertNotNull(serializableSet5);
org.junit.Assert.assertNotNull(serializableArray7);
org.junit.Assert.assertNotNull(serializableSet8);
org.junit.Assert.assertNotNull(serializableArray9);
org.junit.Assert.assertNotNull(serializableSet10);
org.junit.Assert.assertNotNull(serializableArray14);
org.junit.Assert.assertNotNull(serializableSet15);
org.junit.Assert.assertNotNull(serializableArray17);
org.junit.Assert.assertNotNull(serializableSet18);
org.junit.Assert.assertNotNull(serializableArray19);
org.junit.Assert.assertNotNull(serializableSet20);
org.junit.Assert.assertNotNull(serializableArray26);
org.junit.Assert.assertNotNull(serializableSet27);
org.junit.Assert.assertNotNull(serializableArray29);
org.junit.Assert.assertNotNull(serializableSet30);
org.junit.Assert.assertNotNull(serializableArray31);
org.junit.Assert.assertNotNull(serializableSet32);
org.junit.Assert.assertNotNull(serializableArray36);
org.junit.Assert.assertNotNull(serializableSet37);
org.junit.Assert.assertNotNull(serializableArray39);
org.junit.Assert.assertNotNull(serializableSet40);
org.junit.Assert.assertNotNull(serializableArray41);
org.junit.Assert.assertNotNull(serializableSet42);
org.junit.Assert.assertNotNull(serializableArray47);
org.junit.Assert.assertNotNull(serializableSet48);
org.junit.Assert.assertNotNull(serializableArray49);
org.junit.Assert.assertNotNull(serializableSet50);
org.junit.Assert.assertNotNull(serializableArray55);
org.junit.Assert.assertNotNull(serializableSet56);
org.junit.Assert.assertNotNull(serializableArray57);
org.junit.Assert.assertNotNull(serializableSet58);
org.junit.Assert.assertNotNull(executorServiceArray60);
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + true + "'", boolean61 == true);
org.junit.Assert.assertTrue("'" + boolean62 + "' != '" + true + "'", boolean62 == true);
org.junit.Assert.assertTrue("'" + boolean64 + "' != '" + true + "'", boolean64 == true);
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + true + "'", boolean65 == true);
org.junit.Assert.assertNotNull(queryCachingPolicyArray67);
org.junit.Assert.assertNotNull(queryCachingPolicyList68);
}
@Test
public void test17583() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17583");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.maxfailures", postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '4');
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain25 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.Terms terms28 = null;
org.apache.lucene.index.Terms terms29 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.awaitsfix", indexReader27, terms28, terms29, false);
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(ruleChain25);
}
@Test
public void test17584() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17584");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("<unknown>", postingsEnum6, postingsEnum7, true);
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.Fields fields12 = null;
org.apache.lucene.index.Fields fields13 = null;
kuromojiAnalysisTests1.assertFieldsEquals("hi!", indexReader11, fields12, fields13, false);
org.apache.lucene.index.PostingsEnum postingsEnum17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("random", postingsEnum17, postingsEnum18, false);
kuromojiAnalysisTests1.ensureCleanedUp();
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("random", postingsEnum23, postingsEnum24, false);
kuromojiAnalysisTests1.tearDown();
org.junit.Assert.assertNotNull("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests1);
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.setUp();
org.apache.lucene.index.IndexReader indexReader32 = null;
org.apache.lucene.index.IndexReader indexReader33 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.assertNormsEquals("", indexReader32, indexReader33);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
}
@Test
public void test17585() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17585");
org.junit.Assert.assertNotEquals((double) 2, (double) 10L, (double) (byte) 1);
}
@Test
public void test17586() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17586");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader16, 1, postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests25 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule26 = kuromojiAnalysisTests25.ruleChain;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.apache.lucene.util.LuceneTestCase.classRules = testRule26;
org.junit.rules.RuleChain ruleChain29 = org.junit.rules.RuleChain.outerRule(testRule26);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests30 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule31 = kuromojiAnalysisTests30.ruleChain;
org.junit.rules.RuleChain ruleChain32 = org.junit.rules.RuleChain.outerRule(testRule31);
org.junit.rules.RuleChain ruleChain33 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain32);
org.junit.rules.RuleChain ruleChain34 = ruleChain29.around((org.junit.rules.TestRule) ruleChain33);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain33;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests36 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests36.tearDown();
org.apache.lucene.index.IndexReader indexReader39 = null;
org.apache.lucene.index.Terms terms40 = null;
org.apache.lucene.index.Terms terms41 = null;
kuromojiAnalysisTests36.assertTermsEquals("tests.failfast", indexReader39, terms40, terms41, false);
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
org.apache.lucene.index.PostingsEnum postingsEnum48 = null;
kuromojiAnalysisTests36.assertDocsSkippingEquals("tests.nightly", indexReader45, (int) (byte) -1, postingsEnum47, postingsEnum48, false);
org.apache.lucene.index.IndexReader indexReader52 = null;
org.apache.lucene.index.PostingsEnum postingsEnum54 = null;
org.apache.lucene.index.PostingsEnum postingsEnum55 = null;
kuromojiAnalysisTests36.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader52, (int) (short) -1, postingsEnum54, postingsEnum55);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests58 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule59 = kuromojiAnalysisTests58.ruleChain;
kuromojiAnalysisTests58.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests58);
org.junit.rules.RuleChain ruleChain62 = kuromojiAnalysisTests58.failureAndSuccessEvents;
kuromojiAnalysisTests36.failureAndSuccessEvents = ruleChain62;
org.apache.lucene.index.IndexReader indexReader65 = null;
org.apache.lucene.index.PostingsEnum postingsEnum67 = null;
org.apache.lucene.index.PostingsEnum postingsEnum68 = null;
kuromojiAnalysisTests36.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader65, (int) (byte) 100, postingsEnum67, postingsEnum68);
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) "enwiki.random.lines.txt");
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.rules.RuleChain ruleChain72 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
org.junit.Assert.assertNotNull(testRule26);
org.junit.Assert.assertNotNull(ruleChain29);
org.junit.Assert.assertNotNull(testRule31);
org.junit.Assert.assertNotNull(ruleChain32);
org.junit.Assert.assertNotNull(ruleChain33);
org.junit.Assert.assertNotNull(ruleChain34);
org.junit.Assert.assertNotNull(testRule59);
org.junit.Assert.assertNotNull(ruleChain62);
org.junit.Assert.assertNotNull(ruleChain72);
}
@Test
public void test17587() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17587");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
java.lang.String str21 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.setUp();
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum26 = null;
org.apache.lucene.index.PostingsEnum postingsEnum27 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.maxfailures", indexReader24, 3, postingsEnum26, postingsEnum27);
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain30 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertEquals("'" + str21 + "' != '" + "<unknown>" + "'", str21, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain30);
}
@Test
public void test17588() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17588");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("hi!", indexReader8, (int) '4', postingsEnum10, postingsEnum11, false);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.Terms terms17 = null;
org.apache.lucene.index.Terms terms18 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.weekly", indexReader16, terms17, terms18, true);
org.apache.lucene.index.IndexReader indexReader22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader22, (int) '#', postingsEnum24, postingsEnum25, false);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testIterationMarkCharFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17589() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17589");
java.util.Random random0 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests2.tearDown();
org.apache.lucene.index.IndexReader indexReader5 = null;
org.apache.lucene.index.Terms terms6 = null;
org.apache.lucene.index.Terms terms7 = null;
kuromojiAnalysisTests2.assertTermsEquals("tests.failfast", indexReader5, terms6, terms7, false);
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
kuromojiAnalysisTests2.assertDocsSkippingEquals("tests.nightly", indexReader11, (int) (byte) -1, postingsEnum13, postingsEnum14, false);
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader18, (int) (short) -1, postingsEnum20, postingsEnum21);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests24 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule25 = kuromojiAnalysisTests24.ruleChain;
kuromojiAnalysisTests24.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests24);
org.junit.rules.RuleChain ruleChain28 = kuromojiAnalysisTests24.failureAndSuccessEvents;
kuromojiAnalysisTests2.failureAndSuccessEvents = ruleChain28;
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
org.apache.lucene.index.PostingsEnum postingsEnum34 = null;
kuromojiAnalysisTests2.assertDocsSkippingEquals("tests.badapples", indexReader31, 0, postingsEnum33, postingsEnum34, true);
kuromojiAnalysisTests2.ensureCheckIndexPassed();
kuromojiAnalysisTests2.setUp();
kuromojiAnalysisTests2.setIndexWriterMaxDocs((int) ' ');
kuromojiAnalysisTests2.tearDown();
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum45 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("hi!", indexReader43, (int) '4', postingsEnum45, postingsEnum46);
org.apache.lucene.document.FieldType fieldType48 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field49 = org.apache.lucene.util.LuceneTestCase.newField(random0, "", (java.lang.Object) '4', fieldType48);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule25);
org.junit.Assert.assertNotNull(ruleChain28);
}
@Test
public void test17590() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17590");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.nightly", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testJapaneseStopFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17591() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17591");
// The following exception was thrown during execution in test generation
try {
java.nio.file.Path path2 = org.apache.lucene.util.LuceneTestCase.createTempFile("europarl.lines.txt.gz", "tests.maxfailures");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17592() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17592");
org.apache.lucene.analysis.TokenStream tokenStream0 = null;
java.lang.String[] strArray3 = new java.lang.String[] { "random", "hi!" };
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.KuromojiAnalysisTests.assertSimpleTSOutput(tokenStream0, strArray3);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(strArray3);
}
@Test
public void test17593() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17593");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests6 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests6.tearDown();
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.Terms terms10 = null;
org.apache.lucene.index.Terms terms11 = null;
kuromojiAnalysisTests6.assertTermsEquals("tests.failfast", indexReader9, terms10, terms11, false);
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
kuromojiAnalysisTests6.assertDocsSkippingEquals("tests.nightly", indexReader15, (int) (byte) -1, postingsEnum17, postingsEnum18, false);
org.junit.rules.RuleChain ruleChain21 = kuromojiAnalysisTests6.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests23 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests23.ruleChain;
kuromojiAnalysisTests23.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests23);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.Terms terms29 = null;
org.apache.lucene.index.Terms terms30 = null;
kuromojiAnalysisTests23.assertTermsEquals("random", indexReader28, terms29, terms30, false);
org.junit.rules.RuleChain ruleChain33 = kuromojiAnalysisTests23.failureAndSuccessEvents;
org.junit.runners.model.Statement statement34 = null;
org.junit.runner.Description description35 = null;
org.junit.runners.model.Statement statement36 = ruleChain33.apply(statement34, description35);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests38 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule39 = kuromojiAnalysisTests38.ruleChain;
kuromojiAnalysisTests38.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests38);
org.apache.lucene.index.IndexReader indexReader43 = null;
org.apache.lucene.index.Terms terms44 = null;
org.apache.lucene.index.Terms terms45 = null;
kuromojiAnalysisTests38.assertTermsEquals("random", indexReader43, terms44, terms45, false);
org.junit.rules.RuleChain ruleChain48 = kuromojiAnalysisTests38.failureAndSuccessEvents;
org.junit.runners.model.Statement statement49 = null;
org.junit.runner.Description description50 = null;
org.junit.runners.model.Statement statement51 = ruleChain48.apply(statement49, description50);
org.junit.runner.Description description52 = null;
org.junit.runners.model.Statement statement53 = ruleChain33.apply(statement51, description52);
org.junit.rules.TestRule testRule54 = org.apache.lucene.util.LuceneTestCase.classRules;
org.junit.rules.RuleChain ruleChain55 = org.junit.rules.RuleChain.outerRule(testRule54);
org.junit.rules.RuleChain ruleChain56 = ruleChain33.around(testRule54);
org.junit.rules.RuleChain ruleChain57 = ruleChain21.around((org.junit.rules.TestRule) ruleChain56);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain21;
org.apache.lucene.index.IndexReader indexReader60 = null;
org.apache.lucene.index.PostingsEnum postingsEnum62 = null;
org.apache.lucene.index.PostingsEnum postingsEnum63 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("", indexReader60, (int) (byte) 0, postingsEnum62, postingsEnum63);
org.junit.rules.TestRule testRule65 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.PostingsEnum postingsEnum68 = null;
org.apache.lucene.index.PostingsEnum postingsEnum69 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.weekly", postingsEnum68, postingsEnum69, false);
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain21);
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain33);
org.junit.Assert.assertNotNull(statement36);
org.junit.Assert.assertNotNull(testRule39);
org.junit.Assert.assertNotNull(ruleChain48);
org.junit.Assert.assertNotNull(statement51);
org.junit.Assert.assertNotNull(statement53);
org.junit.Assert.assertNotNull(testRule54);
org.junit.Assert.assertNotNull(ruleChain55);
org.junit.Assert.assertNotNull(ruleChain56);
org.junit.Assert.assertNotNull(ruleChain57);
org.junit.Assert.assertNotNull(testRule65);
}
@Test
public void test17594() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17594");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
org.junit.rules.RuleChain ruleChain16 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain17 = kuromojiAnalysisTests1.failureAndSuccessEvents;
double[] doubleArray18 = new double[] {};
double[] doubleArray19 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray18, doubleArray19, (double) '4');
double[] doubleArray22 = new double[] {};
double[] doubleArray23 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray22, doubleArray23, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray19, doubleArray23, (double) (byte) -1);
double[] doubleArray28 = new double[] {};
double[] doubleArray29 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray28, doubleArray29, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray19, doubleArray28, (double) 2);
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain17, (java.lang.Object) doubleArray19);
double[] doubleArray36 = new double[] {};
double[] doubleArray37 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray36, doubleArray37, (double) '4');
double[] doubleArray40 = new double[] {};
double[] doubleArray41 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray40, doubleArray41, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray37, doubleArray41, (double) (byte) -1);
double[] doubleArray46 = new double[] {};
double[] doubleArray47 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray46, doubleArray47, (double) '4');
org.junit.Assert.assertArrayEquals("tests.failfast", doubleArray37, doubleArray47, (double) 0);
double[] doubleArray52 = new double[] {};
double[] doubleArray53 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray52, doubleArray53, (double) '4');
double[] doubleArray56 = new double[] {};
double[] doubleArray57 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray56, doubleArray57, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray52, doubleArray57, (double) (short) 10);
double[] doubleArray62 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray52, doubleArray62, (double) 10L);
org.junit.Assert.assertArrayEquals(doubleArray37, doubleArray52, (double) 4);
org.junit.Assert.assertArrayEquals("", doubleArray19, doubleArray37, (double) 'a');
org.junit.Assert.assertNotNull(ruleChain16);
org.junit.Assert.assertNotNull(ruleChain17);
org.junit.Assert.assertNotNull(doubleArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray18), "[]");
org.junit.Assert.assertNotNull(doubleArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray19), "[]");
org.junit.Assert.assertNotNull(doubleArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray22), "[]");
org.junit.Assert.assertNotNull(doubleArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray23), "[]");
org.junit.Assert.assertNotNull(doubleArray28);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray28), "[]");
org.junit.Assert.assertNotNull(doubleArray29);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray29), "[]");
org.junit.Assert.assertNotNull(doubleArray36);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray36), "[]");
org.junit.Assert.assertNotNull(doubleArray37);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray37), "[]");
org.junit.Assert.assertNotNull(doubleArray40);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray40), "[]");
org.junit.Assert.assertNotNull(doubleArray41);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray41), "[]");
org.junit.Assert.assertNotNull(doubleArray46);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray46), "[]");
org.junit.Assert.assertNotNull(doubleArray47);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray47), "[]");
org.junit.Assert.assertNotNull(doubleArray52);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray52), "[]");
org.junit.Assert.assertNotNull(doubleArray53);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray53), "[]");
org.junit.Assert.assertNotNull(doubleArray56);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray56), "[]");
org.junit.Assert.assertNotNull(doubleArray57);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray57), "[]");
org.junit.Assert.assertNotNull(doubleArray62);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray62), "[]");
}
@Test
public void test17595() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17595");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests0.ruleChain;
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader19, 1, postingsEnum21, postingsEnum22, false);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.PostingsEnum postingsEnum27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum28 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("europarl.lines.txt.gz", postingsEnum27, postingsEnum28, false);
org.apache.lucene.index.IndexReader indexReader32 = null;
org.apache.lucene.index.PostingsEnum postingsEnum34 = null;
org.apache.lucene.index.PostingsEnum postingsEnum35 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("europarl.lines.txt.gz", indexReader32, 2, postingsEnum34, postingsEnum35, true);
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertNotNull(testRule17);
}
@Test
public void test17596() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17596");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader3, terms4, terms5, false);
kuromojiAnalysisTests1.ensureCleanedUp();
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.assertPathHasBeenCleared("enwiki.random.lines.txt");
kuromojiAnalysisTests1.resetCheckIndexStatus();
kuromojiAnalysisTests1.ensureCleanedUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests15 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests15.tearDown();
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.Fields fields19 = null;
org.apache.lucene.index.Fields fields20 = null;
kuromojiAnalysisTests15.assertFieldsEquals("enwiki.random.lines.txt", indexReader18, fields19, fields20, true);
kuromojiAnalysisTests15.setUp();
kuromojiAnalysisTests15.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests15.resetCheckIndexStatus();
kuromojiAnalysisTests15.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests15.ensureCleanedUp();
kuromojiAnalysisTests15.ensureCheckIndexPassed();
kuromojiAnalysisTests15.ensureAllSearchContextsReleased();
kuromojiAnalysisTests15.ensureCleanedUp();
kuromojiAnalysisTests15.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader35 = null;
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests15.assertPositionsSkippingEquals("tests.nightly", indexReader35, 0, postingsEnum37, postingsEnum38);
kuromojiAnalysisTests15.setUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests41 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests41.tearDown();
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.Fields fields45 = null;
org.apache.lucene.index.Fields fields46 = null;
kuromojiAnalysisTests41.assertFieldsEquals("enwiki.random.lines.txt", indexReader44, fields45, fields46, true);
org.apache.lucene.index.IndexReader indexReader50 = null;
org.apache.lucene.index.PostingsEnum postingsEnum52 = null;
org.apache.lucene.index.PostingsEnum postingsEnum53 = null;
kuromojiAnalysisTests41.assertDocsSkippingEquals("", indexReader50, 1, postingsEnum52, postingsEnum53, false);
org.apache.lucene.index.IndexReader indexReader57 = null;
org.apache.lucene.index.PostingsEnum postingsEnum59 = null;
org.apache.lucene.index.PostingsEnum postingsEnum60 = null;
kuromojiAnalysisTests41.assertDocsSkippingEquals("tests.weekly", indexReader57, 1, postingsEnum59, postingsEnum60, false);
kuromojiAnalysisTests41.resetCheckIndexStatus();
kuromojiAnalysisTests41.ensureAllSearchContextsReleased();
kuromojiAnalysisTests41.ensureCheckIndexPassed();
org.junit.Assert.assertNotSame("tests.nightly", (java.lang.Object) kuromojiAnalysisTests15, (java.lang.Object) kuromojiAnalysisTests41);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.Fields fields69 = null;
org.apache.lucene.index.Fields fields70 = null;
kuromojiAnalysisTests15.assertFieldsEquals("tests.badapples", indexReader68, fields69, fields70, true);
org.junit.Assert.assertNotEquals("hi!", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) indexReader68);
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService74 = kuromojiAnalysisTests1.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17597() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17597");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain4 = kuromojiAnalysisTests1.failureAndSuccessEvents;
kuromojiAnalysisTests1.setIndexWriterMaxDocs((int) (short) 1);
kuromojiAnalysisTests1.tearDown();
org.junit.rules.TestRule testRule8 = kuromojiAnalysisTests1.ruleChain;
org.junit.Assert.assertNotNull("", (java.lang.Object) kuromojiAnalysisTests1);
java.io.Reader reader10 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str11 = kuromojiAnalysisTests1.readFully(reader10);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(ruleChain4);
org.junit.Assert.assertNotNull(testRule8);
}
@Test
public void test17598() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17598");
org.junit.Assert.assertNotEquals("tests.badapples", (double) 2, 100.0d, (double) 0);
}
@Test
public void test17599() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17599");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader3, terms4, terms5, false);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
java.lang.String str11 = kuromojiAnalysisTests1.getTestName();
org.junit.rules.RuleChain ruleChain12 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain12;
org.junit.rules.TestRule testRule14 = null;
org.junit.rules.RuleChain ruleChain15 = ruleChain12.around(testRule14);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests16 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests16.tearDown();
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.Terms terms20 = null;
org.apache.lucene.index.Terms terms21 = null;
kuromojiAnalysisTests16.assertTermsEquals("tests.failfast", indexReader19, terms20, terms21, false);
org.apache.lucene.index.IndexReader indexReader25 = null;
org.apache.lucene.index.PostingsEnum postingsEnum27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum28 = null;
kuromojiAnalysisTests16.assertDocsSkippingEquals("tests.nightly", indexReader25, (int) (byte) -1, postingsEnum27, postingsEnum28, false);
org.apache.lucene.index.IndexReader indexReader32 = null;
org.apache.lucene.index.PostingsEnum postingsEnum34 = null;
org.apache.lucene.index.PostingsEnum postingsEnum35 = null;
kuromojiAnalysisTests16.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader32, (int) (short) -1, postingsEnum34, postingsEnum35);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests38 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule39 = kuromojiAnalysisTests38.ruleChain;
kuromojiAnalysisTests38.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests38);
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests38.failureAndSuccessEvents;
kuromojiAnalysisTests16.failureAndSuccessEvents = ruleChain42;
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
org.apache.lucene.index.PostingsEnum postingsEnum48 = null;
kuromojiAnalysisTests16.assertDocsSkippingEquals("tests.badapples", indexReader45, 0, postingsEnum47, postingsEnum48, true);
kuromojiAnalysisTests16.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader53 = null;
org.apache.lucene.index.Fields fields54 = null;
org.apache.lucene.index.Fields fields55 = null;
kuromojiAnalysisTests16.assertFieldsEquals("europarl.lines.txt.gz", indexReader53, fields54, fields55, false);
kuromojiAnalysisTests16.setUp();
kuromojiAnalysisTests16.setIndexWriterMaxDocs((int) '#');
kuromojiAnalysisTests16.resetCheckIndexStatus();
kuromojiAnalysisTests16.overrideTestDefaultQueryCache();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests63 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader65 = null;
org.apache.lucene.index.Terms terms66 = null;
org.apache.lucene.index.Terms terms67 = null;
kuromojiAnalysisTests63.assertTermsEquals("", indexReader65, terms66, terms67, false);
kuromojiAnalysisTests63.setUp();
org.junit.rules.RuleChain ruleChain71 = kuromojiAnalysisTests63.failureAndSuccessEvents;
kuromojiAnalysisTests16.failureAndSuccessEvents = ruleChain71;
org.junit.Assert.assertNotEquals("tests.failfast", (java.lang.Object) testRule14, (java.lang.Object) kuromojiAnalysisTests16);
org.apache.lucene.index.IndexReader indexReader75 = null;
org.apache.lucene.index.IndexReader indexReader76 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests16.assertDeletedDocsEquals("europarl.lines.txt.gz", indexReader75, indexReader76);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "<unknown>" + "'", str11, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain12);
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule39);
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(ruleChain71);
}
@Test
public void test17600() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17600");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.nightly", indexReader20, 0, postingsEnum22, postingsEnum23);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.Fields fields28 = null;
org.apache.lucene.index.Fields fields29 = null;
kuromojiAnalysisTests0.assertFieldsEquals("<unknown>", indexReader27, fields28, fields29, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
}
@Test
public void test17601() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17601");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.junit.rules.RuleChain ruleChain12 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests14 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule15 = kuromojiAnalysisTests14.ruleChain;
kuromojiAnalysisTests14.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests14);
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.Terms terms20 = null;
org.apache.lucene.index.Terms terms21 = null;
kuromojiAnalysisTests14.assertTermsEquals("random", indexReader19, terms20, terms21, false);
org.junit.rules.RuleChain ruleChain24 = kuromojiAnalysisTests14.failureAndSuccessEvents;
org.junit.runners.model.Statement statement25 = null;
org.junit.runner.Description description26 = null;
org.junit.runners.model.Statement statement27 = ruleChain24.apply(statement25, description26);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests29 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule30 = kuromojiAnalysisTests29.ruleChain;
kuromojiAnalysisTests29.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests29);
org.apache.lucene.index.IndexReader indexReader34 = null;
org.apache.lucene.index.Terms terms35 = null;
org.apache.lucene.index.Terms terms36 = null;
kuromojiAnalysisTests29.assertTermsEquals("random", indexReader34, terms35, terms36, false);
org.junit.rules.RuleChain ruleChain39 = kuromojiAnalysisTests29.failureAndSuccessEvents;
org.junit.runners.model.Statement statement40 = null;
org.junit.runner.Description description41 = null;
org.junit.runners.model.Statement statement42 = ruleChain39.apply(statement40, description41);
org.junit.runner.Description description43 = null;
org.junit.runners.model.Statement statement44 = ruleChain24.apply(statement42, description43);
org.junit.runner.Description description45 = null;
org.junit.runners.model.Statement statement46 = ruleChain12.apply(statement42, description45);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests47 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests47.tearDown();
org.apache.lucene.index.IndexReader indexReader50 = null;
org.apache.lucene.index.Terms terms51 = null;
org.apache.lucene.index.Terms terms52 = null;
kuromojiAnalysisTests47.assertTermsEquals("tests.failfast", indexReader50, terms51, terms52, false);
org.apache.lucene.index.IndexReader indexReader56 = null;
org.apache.lucene.index.PostingsEnum postingsEnum58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum59 = null;
kuromojiAnalysisTests47.assertDocsSkippingEquals("tests.nightly", indexReader56, (int) (byte) -1, postingsEnum58, postingsEnum59, false);
org.apache.lucene.index.IndexReader indexReader63 = null;
org.apache.lucene.index.PostingsEnum postingsEnum65 = null;
org.apache.lucene.index.PostingsEnum postingsEnum66 = null;
kuromojiAnalysisTests47.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader63, (int) (short) -1, postingsEnum65, postingsEnum66);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests69 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule70 = kuromojiAnalysisTests69.ruleChain;
kuromojiAnalysisTests69.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests69);
org.junit.rules.RuleChain ruleChain73 = kuromojiAnalysisTests69.failureAndSuccessEvents;
kuromojiAnalysisTests47.failureAndSuccessEvents = ruleChain73;
org.apache.lucene.index.IndexReader indexReader76 = null;
org.apache.lucene.index.PostingsEnum postingsEnum78 = null;
org.apache.lucene.index.PostingsEnum postingsEnum79 = null;
kuromojiAnalysisTests47.assertDocsSkippingEquals("tests.badapples", indexReader76, 0, postingsEnum78, postingsEnum79, true);
kuromojiAnalysisTests47.resetCheckIndexStatus();
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain12, (java.lang.Object) kuromojiAnalysisTests47);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests84 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule85 = kuromojiAnalysisTests84.ruleChain;
org.junit.rules.RuleChain ruleChain86 = org.junit.rules.RuleChain.outerRule(testRule85);
org.junit.rules.RuleChain ruleChain87 = ruleChain12.around(testRule85);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain12;
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.rules.RuleChain ruleChain90 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain91 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.assertPathHasBeenCleared("hi!");
kuromojiAnalysisTests0.tearDown();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testKatakanaStemFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain12);
org.junit.Assert.assertNotNull(testRule15);
org.junit.Assert.assertNotNull(ruleChain24);
org.junit.Assert.assertNotNull(statement27);
org.junit.Assert.assertNotNull(testRule30);
org.junit.Assert.assertNotNull(ruleChain39);
org.junit.Assert.assertNotNull(statement42);
org.junit.Assert.assertNotNull(statement44);
org.junit.Assert.assertNotNull(statement46);
org.junit.Assert.assertNotNull(testRule70);
org.junit.Assert.assertNotNull(ruleChain73);
org.junit.Assert.assertNotNull(testRule85);
org.junit.Assert.assertNotNull(ruleChain86);
org.junit.Assert.assertNotNull(ruleChain87);
org.junit.Assert.assertNotNull(ruleChain90);
org.junit.Assert.assertNotNull(ruleChain91);
}
@Test
public void test17602() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17602");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.ensureCleanedUp();
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.awaitsfix", postingsEnum13, postingsEnum14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests1.ruleChain;
org.junit.rules.TestRule testRule18 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests1.assertTermsEquals("hi!", indexReader21, terms22, terms23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.Terms terms28 = null;
org.apache.lucene.index.Terms terms29 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.awaitsfix", indexReader27, terms28, terms29, false);
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertNotNull(testRule18);
}
@Test
public void test17603() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17603");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests0.ruleChain;
java.lang.String str18 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.RuleChain ruleChain19 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests20 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests20.tearDown();
kuromojiAnalysisTests20.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests20.ensureCleanedUp();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests20.ruleChain;
kuromojiAnalysisTests20.assertPathHasBeenCleared("europarl.lines.txt.gz");
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain19, (java.lang.Object) kuromojiAnalysisTests20);
kuromojiAnalysisTests20.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.IndexReader indexReader31 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests20.assertDocValuesEquals("hi!", indexReader30, indexReader31);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "<unknown>" + "'", str18, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(testRule24);
}
@Test
public void test17604() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17604");
// The following exception was thrown during execution in test generation
try {
int int2 = org.elasticsearch.test.ESTestCase.scaledRandomIntBetween(2, (int) (byte) 100);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17605() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17605");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("random", indexReader16, (int) ' ', postingsEnum18, postingsEnum19, true);
kuromojiAnalysisTests0.tearDown();
java.io.Serializable[] serializableArray27 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet28 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray27);
java.io.Serializable[] serializableArray30 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet31 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray30);
java.io.Serializable[] serializableArray32 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet33 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray32);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray30, (java.lang.Object[]) serializableArray32);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray27, (java.lang.Object[]) serializableArray32);
java.io.Serializable[] serializableArray37 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet38 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray37);
java.io.Serializable[] serializableArray40 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet41 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray40);
java.io.Serializable[] serializableArray42 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet43 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray42);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray40, (java.lang.Object[]) serializableArray42);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray37, (java.lang.Object[]) serializableArray42);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray27, (java.lang.Object[]) serializableArray37);
java.io.Serializable[] serializableArray50 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet51 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray50);
java.io.Serializable[] serializableArray53 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet54 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray53);
java.io.Serializable[] serializableArray55 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet56 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray55);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray53, (java.lang.Object[]) serializableArray55);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray50, (java.lang.Object[]) serializableArray55);
java.io.Serializable[] serializableArray60 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet61 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray60);
java.io.Serializable[] serializableArray63 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet64 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray63);
java.io.Serializable[] serializableArray65 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet66 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray65);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray63, (java.lang.Object[]) serializableArray65);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray60, (java.lang.Object[]) serializableArray65);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray50, (java.lang.Object[]) serializableArray60);
java.io.Serializable[] serializableArray71 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet72 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray71);
java.io.Serializable[] serializableArray73 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet74 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray73);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray71, (java.lang.Object[]) serializableArray73);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray50, (java.lang.Object[]) serializableArray71);
org.junit.Assert.assertNotNull("tests.awaitsfix", (java.lang.Object) serializableArray71);
org.junit.Assert.assertArrayEquals("tests.nightly", (java.lang.Object[]) serializableArray37, (java.lang.Object[]) serializableArray71);
java.util.concurrent.ExecutorService[] executorServiceArray79 = new java.util.concurrent.ExecutorService[] {};
boolean boolean80 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray79);
org.junit.Assert.assertEquals("tests.nightly", (java.lang.Object[]) serializableArray71, (java.lang.Object[]) executorServiceArray79);
boolean boolean82 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray79);
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) boolean82);
org.apache.lucene.index.IndexReader indexReader85 = null;
org.apache.lucene.index.IndexReader indexReader86 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertNormsEquals("tests.nightly", indexReader85, indexReader86);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(serializableArray27);
org.junit.Assert.assertNotNull(serializableSet28);
org.junit.Assert.assertNotNull(serializableArray30);
org.junit.Assert.assertNotNull(serializableSet31);
org.junit.Assert.assertNotNull(serializableArray32);
org.junit.Assert.assertNotNull(serializableSet33);
org.junit.Assert.assertNotNull(serializableArray37);
org.junit.Assert.assertNotNull(serializableSet38);
org.junit.Assert.assertNotNull(serializableArray40);
org.junit.Assert.assertNotNull(serializableSet41);
org.junit.Assert.assertNotNull(serializableArray42);
org.junit.Assert.assertNotNull(serializableSet43);
org.junit.Assert.assertNotNull(serializableArray50);
org.junit.Assert.assertNotNull(serializableSet51);
org.junit.Assert.assertNotNull(serializableArray53);
org.junit.Assert.assertNotNull(serializableSet54);
org.junit.Assert.assertNotNull(serializableArray55);
org.junit.Assert.assertNotNull(serializableSet56);
org.junit.Assert.assertNotNull(serializableArray60);
org.junit.Assert.assertNotNull(serializableSet61);
org.junit.Assert.assertNotNull(serializableArray63);
org.junit.Assert.assertNotNull(serializableSet64);
org.junit.Assert.assertNotNull(serializableArray65);
org.junit.Assert.assertNotNull(serializableSet66);
org.junit.Assert.assertNotNull(serializableArray71);
org.junit.Assert.assertNotNull(serializableSet72);
org.junit.Assert.assertNotNull(serializableArray73);
org.junit.Assert.assertNotNull(serializableSet74);
org.junit.Assert.assertNotNull(executorServiceArray79);
org.junit.Assert.assertTrue("'" + boolean80 + "' != '" + true + "'", boolean80 == true);
org.junit.Assert.assertTrue("'" + boolean82 + "' != '" + true + "'", boolean82 == true);
}
@Test
public void test17606() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17606");
org.apache.lucene.document.FieldType fieldType2 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field3 = org.apache.lucene.util.LuceneTestCase.newField("tests.slow", "", fieldType2);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17607() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17607");
org.junit.Assert.assertEquals((double) 5, (double) 1.0f, (double) 100L);
}
@Test
public void test17608() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17608");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.weekly", indexReader6, (int) (short) 1, postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests11.tearDown();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests11.assertTermsEquals("tests.failfast", indexReader14, terms15, terms16, false);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests11.assertDocsSkippingEquals("tests.nightly", indexReader20, (int) (byte) -1, postingsEnum22, postingsEnum23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests11.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader27, (int) (short) -1, postingsEnum29, postingsEnum30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.junit.rules.RuleChain ruleChain37 = kuromojiAnalysisTests33.failureAndSuccessEvents;
kuromojiAnalysisTests11.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader42 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum45 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.weekly", indexReader42, (int) 'a', postingsEnum44, postingsEnum45, true);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.ensureCleanedUp();
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain37);
}
@Test
public void test17609() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17609");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.Terms terms10 = null;
org.apache.lucene.index.Terms terms11 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader9, terms10, terms11, false);
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Fields fields16 = null;
org.apache.lucene.index.Fields fields17 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.nightly", indexReader15, fields16, fields17, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("<unknown>", indexReader22, (int) (short) 100, postingsEnum24, postingsEnum25, true);
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.nightly", indexReader29, (int) (short) 100, postingsEnum31, postingsEnum32);
kuromojiAnalysisTests0.ensureCleanedUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests36 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule37 = kuromojiAnalysisTests36.ruleChain;
kuromojiAnalysisTests36.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests36);
org.apache.lucene.index.IndexReader indexReader41 = null;
org.apache.lucene.index.Terms terms42 = null;
org.apache.lucene.index.Terms terms43 = null;
kuromojiAnalysisTests36.assertTermsEquals("random", indexReader41, terms42, terms43, false);
kuromojiAnalysisTests36.ensureCheckIndexPassed();
kuromojiAnalysisTests36.ensureCheckIndexPassed();
org.junit.rules.RuleChain ruleChain48 = kuromojiAnalysisTests36.failureAndSuccessEvents;
org.junit.rules.TestRule testRule49 = kuromojiAnalysisTests36.ruleChain;
org.junit.rules.RuleChain ruleChain50 = org.junit.rules.RuleChain.outerRule(testRule49);
org.junit.rules.RuleChain ruleChain51 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain50);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain50;
// The following exception was thrown during execution in test generation
try {
java.nio.file.Path path54 = kuromojiAnalysisTests0.getDataPath("tests.monster");
org.junit.Assert.fail("Expected exception of type java.lang.RuntimeException; message: resource not found: tests.monster");
} catch (java.lang.RuntimeException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule37);
org.junit.Assert.assertNotNull(ruleChain48);
org.junit.Assert.assertNotNull(testRule49);
org.junit.Assert.assertNotNull(ruleChain50);
org.junit.Assert.assertNotNull(ruleChain51);
}
@Test
public void test17610() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17610");
org.junit.Assert.assertEquals((float) (byte) 10, (float) 100, 100.0f);
}
@Test
public void test17611() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17611");
java.util.Random random0 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests2.tearDown();
kuromojiAnalysisTests2.overrideTestDefaultQueryCache();
kuromojiAnalysisTests2.setUp();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Fields fields11 = null;
org.apache.lucene.index.Fields fields12 = null;
kuromojiAnalysisTests2.assertFieldsEquals("tests.badapples", indexReader10, fields11, fields12, false);
kuromojiAnalysisTests2.setUp();
org.apache.lucene.document.FieldType fieldType16 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field17 = org.apache.lucene.util.LuceneTestCase.newField(random0, "<unknown>", (java.lang.Object) kuromojiAnalysisTests2, fieldType16);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule3);
}
@Test
public void test17612() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17612");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
java.lang.String str42 = kuromojiAnalysisTests0.getTestName();
java.lang.String str43 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.nightly", indexReader45, terms46, terms47, true);
org.apache.lucene.index.IndexReader indexReader51 = null;
org.apache.lucene.index.Fields fields52 = null;
org.apache.lucene.index.Fields fields53 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader51, fields52, fields53, true);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testDefaultsKuromojiAnalysis();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "<unknown>" + "'", str42, "<unknown>");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "<unknown>" + "'", str43, "<unknown>");
}
@Test
public void test17613() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17613");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setUp();
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("random", postingsEnum11, postingsEnum12, false);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
}
@Test
public void test17614() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17614");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Fields fields15 = null;
org.apache.lucene.index.Fields fields16 = null;
kuromojiAnalysisTests0.assertFieldsEquals("hi!", indexReader14, fields15, fields16, false);
}
@Test
public void test17615() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17615");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.Fields fields12 = null;
org.apache.lucene.index.Fields fields13 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.monster", indexReader11, fields12, fields13, false);
org.junit.rules.RuleChain ruleChain16 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.Assert.assertNotNull(ruleChain16);
}
@Test
public void test17616() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17616");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Terms terms11 = null;
org.apache.lucene.index.Terms terms12 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.slow", indexReader10, terms11, terms12, false);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("", indexReader17, (int) (byte) 10, postingsEnum19, postingsEnum20);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum26 = null;
org.apache.lucene.index.PostingsEnum postingsEnum27 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.maxfailures", indexReader24, (int) '#', postingsEnum26, postingsEnum27, false);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testBaseFormFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17617() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17617");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.junit.rules.TestRule testRule9 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.junit.rules.TestRule testRule11 = kuromojiAnalysisTests0.ruleChain;
org.junit.rules.RuleChain ruleChain12 = org.junit.rules.RuleChain.outerRule(testRule11);
org.junit.Assert.assertNotNull(testRule9);
org.junit.Assert.assertNotNull(testRule11);
org.junit.Assert.assertNotNull(ruleChain12);
}
@Test
public void test17618() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17618");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.weekly", indexReader6, (int) (short) 1, postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests11.tearDown();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests11.assertTermsEquals("tests.failfast", indexReader14, terms15, terms16, false);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests11.assertDocsSkippingEquals("tests.nightly", indexReader20, (int) (byte) -1, postingsEnum22, postingsEnum23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests11.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader27, (int) (short) -1, postingsEnum29, postingsEnum30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.junit.rules.RuleChain ruleChain37 = kuromojiAnalysisTests33.failureAndSuccessEvents;
kuromojiAnalysisTests11.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain37;
org.junit.rules.RuleChain ruleChain40 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain37);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain37;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests42 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests42.tearDown();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Fields fields46 = null;
org.apache.lucene.index.Fields fields47 = null;
kuromojiAnalysisTests42.assertFieldsEquals("enwiki.random.lines.txt", indexReader45, fields46, fields47, true);
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum52 = null;
kuromojiAnalysisTests42.assertDocsEnumEquals("tests.monster", postingsEnum51, postingsEnum52, true);
kuromojiAnalysisTests42.resetCheckIndexStatus();
kuromojiAnalysisTests42.ensureCleanedUp();
kuromojiAnalysisTests42.overrideTestDefaultQueryCache();
kuromojiAnalysisTests42.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain37, (java.lang.Object) kuromojiAnalysisTests42);
kuromojiAnalysisTests42.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader62 = null;
org.apache.lucene.index.PostingsEnum postingsEnum64 = null;
org.apache.lucene.index.PostingsEnum postingsEnum65 = null;
kuromojiAnalysisTests42.assertPositionsSkippingEquals("tests.failfast", indexReader62, (int) (short) 0, postingsEnum64, postingsEnum65);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.IndexReader indexReader69 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests42.assertFieldInfosEquals("enwiki.random.lines.txt", indexReader68, indexReader69);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain37);
org.junit.Assert.assertNotNull(ruleChain40);
}
@Test
public void test17619() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17619");
java.lang.Object obj1 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests2.tearDown();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests4 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests4.tearDown();
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.Terms terms8 = null;
org.apache.lucene.index.Terms terms9 = null;
kuromojiAnalysisTests4.assertTermsEquals("tests.failfast", indexReader7, terms8, terms9, false);
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Terms terms14 = null;
org.apache.lucene.index.Terms terms15 = null;
kuromojiAnalysisTests4.assertTermsEquals("", indexReader13, terms14, terms15, false);
org.junit.rules.RuleChain ruleChain18 = kuromojiAnalysisTests4.failureAndSuccessEvents;
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests2, (java.lang.Object) kuromojiAnalysisTests4);
kuromojiAnalysisTests4.ensureCleanedUp();
kuromojiAnalysisTests4.setIndexWriterMaxDocs((int) ' ');
kuromojiAnalysisTests4.overrideTestDefaultQueryCache();
kuromojiAnalysisTests4.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests4.assertDocsSkippingEquals("tests.monster", indexReader27, 3, postingsEnum29, postingsEnum30, true);
org.junit.Assert.assertNotSame("tests.maxfailures", obj1, (java.lang.Object) 3);
org.junit.Assert.assertNotNull(ruleChain18);
}
@Test
public void test17620() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17620");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
java.lang.String str10 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests13 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule14 = kuromojiAnalysisTests13.ruleChain;
kuromojiAnalysisTests13.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests13);
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
kuromojiAnalysisTests13.assertPositionsSkippingEquals("tests.weekly", indexReader18, (int) (short) 1, postingsEnum20, postingsEnum21);
java.lang.String str23 = kuromojiAnalysisTests13.getTestName();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests13.ruleChain;
org.junit.rules.RuleChain ruleChain25 = org.junit.rules.RuleChain.outerRule(testRule24);
org.junit.rules.RuleChain ruleChain26 = ruleChain11.around((org.junit.rules.TestRule) ruleChain25);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests28 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule29 = kuromojiAnalysisTests28.ruleChain;
kuromojiAnalysisTests28.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests28);
org.apache.lucene.index.IndexReader indexReader33 = null;
org.apache.lucene.index.Terms terms34 = null;
org.apache.lucene.index.Terms terms35 = null;
kuromojiAnalysisTests28.assertTermsEquals("random", indexReader33, terms34, terms35, false);
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests28.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain39 = kuromojiAnalysisTests28.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests41 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule42 = kuromojiAnalysisTests41.ruleChain;
kuromojiAnalysisTests41.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests41);
org.apache.lucene.index.IndexReader indexReader46 = null;
org.apache.lucene.index.Terms terms47 = null;
org.apache.lucene.index.Terms terms48 = null;
kuromojiAnalysisTests41.assertTermsEquals("random", indexReader46, terms47, terms48, false);
org.junit.rules.RuleChain ruleChain51 = kuromojiAnalysisTests41.failureAndSuccessEvents;
org.junit.runners.model.Statement statement52 = null;
org.junit.runner.Description description53 = null;
org.junit.runners.model.Statement statement54 = ruleChain51.apply(statement52, description53);
kuromojiAnalysisTests28.failureAndSuccessEvents = ruleChain51;
kuromojiAnalysisTests28.assertPathHasBeenCleared("tests.badapples");
org.junit.rules.TestRule testRule58 = kuromojiAnalysisTests28.ruleChain;
org.junit.rules.RuleChain ruleChain59 = ruleChain11.around(testRule58);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain59;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests62 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule63 = kuromojiAnalysisTests62.ruleChain;
kuromojiAnalysisTests62.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests62);
org.apache.lucene.index.IndexReader indexReader67 = null;
org.apache.lucene.index.Terms terms68 = null;
org.apache.lucene.index.Terms terms69 = null;
kuromojiAnalysisTests62.assertTermsEquals("random", indexReader67, terms68, terms69, false);
org.junit.rules.RuleChain ruleChain72 = kuromojiAnalysisTests62.failureAndSuccessEvents;
org.junit.runners.model.Statement statement73 = null;
org.junit.runner.Description description74 = null;
org.junit.runners.model.Statement statement75 = ruleChain72.apply(statement73, description74);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests77 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule78 = kuromojiAnalysisTests77.ruleChain;
kuromojiAnalysisTests77.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests77);
org.apache.lucene.index.IndexReader indexReader82 = null;
org.apache.lucene.index.Terms terms83 = null;
org.apache.lucene.index.Terms terms84 = null;
kuromojiAnalysisTests77.assertTermsEquals("random", indexReader82, terms83, terms84, false);
org.junit.rules.RuleChain ruleChain87 = kuromojiAnalysisTests77.failureAndSuccessEvents;
org.junit.runners.model.Statement statement88 = null;
org.junit.runner.Description description89 = null;
org.junit.runners.model.Statement statement90 = ruleChain87.apply(statement88, description89);
org.junit.runner.Description description91 = null;
org.junit.runners.model.Statement statement92 = ruleChain72.apply(statement90, description91);
org.junit.runner.Description description93 = null;
// The following exception was thrown during execution in test generation
try {
org.junit.runners.model.Statement statement94 = ruleChain59.apply(statement90, description93);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "<unknown>" + "'", str10, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain11);
org.junit.Assert.assertNotNull(testRule14);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "<unknown>" + "'", str23, "<unknown>");
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain25);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(testRule29);
org.junit.Assert.assertNotNull(ruleChain38);
org.junit.Assert.assertNotNull(ruleChain39);
org.junit.Assert.assertNotNull(testRule42);
org.junit.Assert.assertNotNull(ruleChain51);
org.junit.Assert.assertNotNull(statement54);
org.junit.Assert.assertNotNull(testRule58);
org.junit.Assert.assertNotNull(ruleChain59);
org.junit.Assert.assertNotNull(testRule63);
org.junit.Assert.assertNotNull(ruleChain72);
org.junit.Assert.assertNotNull(statement75);
org.junit.Assert.assertNotNull(testRule78);
org.junit.Assert.assertNotNull(ruleChain87);
org.junit.Assert.assertNotNull(statement90);
org.junit.Assert.assertNotNull(statement92);
}
@Test
public void test17621() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17621");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Fields fields38 = null;
org.apache.lucene.index.Fields fields39 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader37, fields38, fields39, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '#');
org.apache.lucene.index.IndexReader indexReader46 = null;
org.apache.lucene.index.Fields fields47 = null;
org.apache.lucene.index.Fields fields48 = null;
kuromojiAnalysisTests0.assertFieldsEquals("<unknown>", indexReader46, fields47, fields48, true);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 10);
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.weekly");
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17622() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17622");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.junit.rules.RuleChain ruleChain21 = kuromojiAnalysisTests0.failureAndSuccessEvents;
java.lang.String str22 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.IndexReader indexReader29 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertDeletedDocsEquals("random", indexReader28, indexReader29);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain21);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "<unknown>" + "'", str22, "<unknown>");
}
@Test
public void test17623() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17623");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.setUp();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Fields fields14 = null;
org.apache.lucene.index.Fields fields15 = null;
kuromojiAnalysisTests1.assertFieldsEquals("europarl.lines.txt.gz", indexReader13, fields14, fields15, true);
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.awaitsfix", postingsEnum21, postingsEnum22, false);
kuromojiAnalysisTests1.ensureCleanedUp();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.testReadingFormFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
}
@Test
public void test17624() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17624");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
kuromojiAnalysisTests1.resetCheckIndexStatus();
kuromojiAnalysisTests1.resetCheckIndexStatus();
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests12 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests12.tearDown();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Terms terms16 = null;
org.apache.lucene.index.Terms terms17 = null;
kuromojiAnalysisTests12.assertTermsEquals("tests.failfast", indexReader15, terms16, terms17, false);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests12.assertDocsSkippingEquals("tests.nightly", indexReader21, (int) (byte) -1, postingsEnum23, postingsEnum24, false);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
kuromojiAnalysisTests12.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader28, (int) (short) -1, postingsEnum30, postingsEnum31);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests34 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule35 = kuromojiAnalysisTests34.ruleChain;
kuromojiAnalysisTests34.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests34);
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests34.failureAndSuccessEvents;
kuromojiAnalysisTests12.failureAndSuccessEvents = ruleChain38;
org.apache.lucene.index.IndexReader indexReader41 = null;
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
kuromojiAnalysisTests12.assertDocsSkippingEquals("tests.badapples", indexReader41, 0, postingsEnum43, postingsEnum44, true);
org.apache.lucene.index.IndexReader indexReader48 = null;
org.apache.lucene.index.Terms terms49 = null;
org.apache.lucene.index.Terms terms50 = null;
kuromojiAnalysisTests12.assertTermsEquals("random", indexReader48, terms49, terms50, false);
kuromojiAnalysisTests12.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain54 = kuromojiAnalysisTests12.failureAndSuccessEvents;
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain54;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests56 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests56.tearDown();
org.apache.lucene.index.IndexReader indexReader59 = null;
org.apache.lucene.index.Fields fields60 = null;
org.apache.lucene.index.Fields fields61 = null;
kuromojiAnalysisTests56.assertFieldsEquals("enwiki.random.lines.txt", indexReader59, fields60, fields61, true);
kuromojiAnalysisTests56.setUp();
kuromojiAnalysisTests56.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.Fields fields69 = null;
org.apache.lucene.index.Fields fields70 = null;
kuromojiAnalysisTests56.assertFieldsEquals("enwiki.random.lines.txt", indexReader68, fields69, fields70, false);
org.apache.lucene.index.IndexReader indexReader74 = null;
org.apache.lucene.index.Fields fields75 = null;
org.apache.lucene.index.Fields fields76 = null;
kuromojiAnalysisTests56.assertFieldsEquals("", indexReader74, fields75, fields76, false);
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain54, (java.lang.Object) fields76);
org.junit.Assert.assertNotEquals("", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) ruleChain54);
java.lang.String str81 = kuromojiAnalysisTests1.getTestName();
kuromojiAnalysisTests1.setUp();
org.junit.Assert.assertNotNull(testRule35);
org.junit.Assert.assertNotNull(ruleChain38);
org.junit.Assert.assertNotNull(ruleChain54);
org.junit.Assert.assertEquals("'" + str81 + "' != '" + "<unknown>" + "'", str81, "<unknown>");
}
@Test
public void test17625() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17625");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum5 = null;
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("<unknown>", postingsEnum5, postingsEnum6, true);
java.lang.String str9 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.TestRule testRule10 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "<unknown>" + "'", str9, "<unknown>");
org.junit.Assert.assertNotNull(testRule10);
}
@Test
public void test17626() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17626");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests18 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests18.ruleChain;
kuromojiAnalysisTests18.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests18);
org.junit.rules.RuleChain ruleChain22 = kuromojiAnalysisTests18.failureAndSuccessEvents;
kuromojiAnalysisTests18.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) kuromojiAnalysisTests18);
kuromojiAnalysisTests0.ensureCleanedUp();
org.apache.lucene.index.PostingsEnum postingsEnum27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum28 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.maxfailures", postingsEnum27, postingsEnum28, false);
java.io.Reader reader31 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertCharFilterEquals(reader31, "tests.awaitsfix");
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule19);
org.junit.Assert.assertNotNull(ruleChain22);
}
@Test
public void test17627() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17627");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Terms terms11 = null;
org.apache.lucene.index.Terms terms12 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.slow", indexReader10, terms11, terms12, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 100);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader20, (int) (byte) 0, postingsEnum22, postingsEnum23, false);
}
@Test
public void test17628() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17628");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Fields fields9 = null;
org.apache.lucene.index.Fields fields10 = null;
kuromojiAnalysisTests0.assertFieldsEquals("", indexReader8, fields9, fields10, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testBaseFormFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17629() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17629");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader16, 1, postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.nightly");
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
}
@Test
public void test17630() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17630");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.tearDown();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests6 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule7 = kuromojiAnalysisTests6.ruleChain;
kuromojiAnalysisTests6.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests6);
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.Terms terms12 = null;
org.apache.lucene.index.Terms terms13 = null;
kuromojiAnalysisTests6.assertTermsEquals("random", indexReader11, terms12, terms13, false);
org.junit.rules.RuleChain ruleChain16 = kuromojiAnalysisTests6.failureAndSuccessEvents;
org.junit.runners.model.Statement statement17 = null;
org.junit.runner.Description description18 = null;
org.junit.runners.model.Statement statement19 = ruleChain16.apply(statement17, description18);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests21 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule22 = kuromojiAnalysisTests21.ruleChain;
kuromojiAnalysisTests21.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests21);
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.Terms terms27 = null;
org.apache.lucene.index.Terms terms28 = null;
kuromojiAnalysisTests21.assertTermsEquals("random", indexReader26, terms27, terms28, false);
org.junit.rules.RuleChain ruleChain31 = kuromojiAnalysisTests21.failureAndSuccessEvents;
org.junit.runners.model.Statement statement32 = null;
org.junit.runner.Description description33 = null;
org.junit.runners.model.Statement statement34 = ruleChain31.apply(statement32, description33);
org.junit.runner.Description description35 = null;
org.junit.runners.model.Statement statement36 = ruleChain16.apply(statement34, description35);
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain16;
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests39 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests39.tearDown();
org.apache.lucene.index.IndexReader indexReader42 = null;
org.apache.lucene.index.Terms terms43 = null;
org.apache.lucene.index.Terms terms44 = null;
kuromojiAnalysisTests39.assertTermsEquals("tests.failfast", indexReader42, terms43, terms44, false);
org.apache.lucene.index.IndexReader indexReader48 = null;
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
kuromojiAnalysisTests39.assertDocsSkippingEquals("tests.nightly", indexReader48, (int) (byte) -1, postingsEnum50, postingsEnum51, false);
org.junit.rules.RuleChain ruleChain54 = kuromojiAnalysisTests39.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain55 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests57 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule58 = kuromojiAnalysisTests57.ruleChain;
kuromojiAnalysisTests57.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests57);
org.apache.lucene.index.IndexReader indexReader62 = null;
org.apache.lucene.index.Terms terms63 = null;
org.apache.lucene.index.Terms terms64 = null;
kuromojiAnalysisTests57.assertTermsEquals("random", indexReader62, terms63, terms64, false);
org.junit.rules.RuleChain ruleChain67 = kuromojiAnalysisTests57.failureAndSuccessEvents;
org.junit.runners.model.Statement statement68 = null;
org.junit.runner.Description description69 = null;
org.junit.runners.model.Statement statement70 = ruleChain67.apply(statement68, description69);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests72 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule73 = kuromojiAnalysisTests72.ruleChain;
kuromojiAnalysisTests72.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests72);
org.apache.lucene.index.IndexReader indexReader77 = null;
org.apache.lucene.index.Terms terms78 = null;
org.apache.lucene.index.Terms terms79 = null;
kuromojiAnalysisTests72.assertTermsEquals("random", indexReader77, terms78, terms79, false);
org.junit.rules.RuleChain ruleChain82 = kuromojiAnalysisTests72.failureAndSuccessEvents;
org.junit.runners.model.Statement statement83 = null;
org.junit.runner.Description description84 = null;
org.junit.runners.model.Statement statement85 = ruleChain82.apply(statement83, description84);
org.junit.runner.Description description86 = null;
org.junit.runners.model.Statement statement87 = ruleChain67.apply(statement85, description86);
org.junit.runner.Description description88 = null;
org.junit.runners.model.Statement statement89 = ruleChain55.apply(statement85, description88);
org.junit.runner.Description description90 = null;
org.junit.runners.model.Statement statement91 = ruleChain54.apply(statement85, description90);
org.junit.runner.Description description92 = null;
org.junit.runners.model.Statement statement93 = ruleChain38.apply(statement91, description92);
org.junit.Assert.assertNotNull("europarl.lines.txt.gz", (java.lang.Object) ruleChain38);
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule7);
org.junit.Assert.assertNotNull(ruleChain16);
org.junit.Assert.assertNotNull(statement19);
org.junit.Assert.assertNotNull(testRule22);
org.junit.Assert.assertNotNull(ruleChain31);
org.junit.Assert.assertNotNull(statement34);
org.junit.Assert.assertNotNull(statement36);
org.junit.Assert.assertNotNull(ruleChain38);
org.junit.Assert.assertNotNull(ruleChain54);
org.junit.Assert.assertNotNull(ruleChain55);
org.junit.Assert.assertNotNull(testRule58);
org.junit.Assert.assertNotNull(ruleChain67);
org.junit.Assert.assertNotNull(statement70);
org.junit.Assert.assertNotNull(testRule73);
org.junit.Assert.assertNotNull(ruleChain82);
org.junit.Assert.assertNotNull(statement85);
org.junit.Assert.assertNotNull(statement87);
org.junit.Assert.assertNotNull(statement89);
org.junit.Assert.assertNotNull(statement91);
org.junit.Assert.assertNotNull(statement93);
}
@Test
public void test17631() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17631");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomUnicodeOfCodepointLengthBetween((int) (byte) -1, (int) (byte) 100);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17632() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17632");
byte[] byteArray4 = new byte[] {};
byte[] byteArray5 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray4, byteArray5);
byte[] byteArray9 = new byte[] {};
byte[] byteArray10 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray9, byteArray10);
byte[] byteArray13 = new byte[] {};
byte[] byteArray14 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray13, byteArray14);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray9, byteArray13);
byte[] byteArray19 = new byte[] {};
byte[] byteArray20 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray19, byteArray20);
byte[] byteArray23 = new byte[] {};
byte[] byteArray24 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray23, byteArray24);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray19, byteArray23);
org.junit.Assert.assertArrayEquals(byteArray13, byteArray19);
org.junit.Assert.assertArrayEquals("", byteArray4, byteArray13);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests29 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests29.tearDown();
org.apache.lucene.index.IndexReader indexReader32 = null;
org.apache.lucene.index.Terms terms33 = null;
org.apache.lucene.index.Terms terms34 = null;
kuromojiAnalysisTests29.assertTermsEquals("tests.failfast", indexReader32, terms33, terms34, false);
org.apache.lucene.index.IndexReader indexReader38 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
org.apache.lucene.index.PostingsEnum postingsEnum41 = null;
kuromojiAnalysisTests29.assertDocsSkippingEquals("tests.nightly", indexReader38, (int) (byte) -1, postingsEnum40, postingsEnum41, false);
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
org.apache.lucene.index.PostingsEnum postingsEnum48 = null;
kuromojiAnalysisTests29.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader45, (int) (short) -1, postingsEnum47, postingsEnum48);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests51 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule52 = kuromojiAnalysisTests51.ruleChain;
kuromojiAnalysisTests51.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests51);
org.junit.rules.RuleChain ruleChain55 = kuromojiAnalysisTests51.failureAndSuccessEvents;
kuromojiAnalysisTests29.failureAndSuccessEvents = ruleChain55;
org.apache.lucene.index.IndexReader indexReader58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum60 = null;
org.apache.lucene.index.PostingsEnum postingsEnum61 = null;
kuromojiAnalysisTests29.assertDocsSkippingEquals("tests.badapples", indexReader58, 0, postingsEnum60, postingsEnum61, true);
kuromojiAnalysisTests29.ensureCheckIndexPassed();
kuromojiAnalysisTests29.ensureCheckIndexPassed();
kuromojiAnalysisTests29.overrideTestDefaultQueryCache();
kuromojiAnalysisTests29.overrideTestDefaultQueryCache();
org.junit.Assert.assertNotEquals("<unknown>", (java.lang.Object) byteArray13, (java.lang.Object) kuromojiAnalysisTests29);
org.apache.lucene.index.PostingsEnum postingsEnum70 = null;
org.apache.lucene.index.PostingsEnum postingsEnum71 = null;
kuromojiAnalysisTests29.assertDocsEnumEquals("hi!", postingsEnum70, postingsEnum71, true);
org.junit.rules.RuleChain ruleChain74 = kuromojiAnalysisTests29.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests76 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule77 = kuromojiAnalysisTests76.ruleChain;
kuromojiAnalysisTests76.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests76);
org.apache.lucene.index.IndexReader indexReader81 = null;
org.apache.lucene.index.Terms terms82 = null;
org.apache.lucene.index.Terms terms83 = null;
kuromojiAnalysisTests76.assertTermsEquals("random", indexReader81, terms82, terms83, false);
org.junit.rules.RuleChain ruleChain86 = kuromojiAnalysisTests76.failureAndSuccessEvents;
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests76);
org.apache.lucene.index.PostingsEnum postingsEnum89 = null;
org.apache.lucene.index.PostingsEnum postingsEnum90 = null;
kuromojiAnalysisTests76.assertDocsEnumEquals("tests.slow", postingsEnum89, postingsEnum90, true);
org.junit.Assert.assertNotSame("tests.nightly", (java.lang.Object) ruleChain74, (java.lang.Object) kuromojiAnalysisTests76);
org.junit.Assert.assertNotNull((java.lang.Object) "tests.nightly");
org.junit.Assert.assertNotNull(byteArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray4), "[]");
org.junit.Assert.assertNotNull(byteArray5);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray5), "[]");
org.junit.Assert.assertNotNull(byteArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray9), "[]");
org.junit.Assert.assertNotNull(byteArray10);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray10), "[]");
org.junit.Assert.assertNotNull(byteArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray13), "[]");
org.junit.Assert.assertNotNull(byteArray14);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray14), "[]");
org.junit.Assert.assertNotNull(byteArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray19), "[]");
org.junit.Assert.assertNotNull(byteArray20);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray20), "[]");
org.junit.Assert.assertNotNull(byteArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray23), "[]");
org.junit.Assert.assertNotNull(byteArray24);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray24), "[]");
org.junit.Assert.assertNotNull(testRule52);
org.junit.Assert.assertNotNull(ruleChain55);
org.junit.Assert.assertNotNull(ruleChain74);
org.junit.Assert.assertNotNull(testRule77);
org.junit.Assert.assertNotNull(ruleChain86);
}
@Test
public void test17633() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17633");
java.util.Random random0 = null;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader5 = null;
org.apache.lucene.index.Terms terms6 = null;
org.apache.lucene.index.Terms terms7 = null;
kuromojiAnalysisTests3.assertTermsEquals("", indexReader5, terms6, terms7, false);
kuromojiAnalysisTests3.setUp();
kuromojiAnalysisTests3.ensureAllSearchContextsReleased();
char[] charArray14 = new char[] {};
char[] charArray15 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray14, charArray15);
char[] charArray17 = new char[] {};
char[] charArray18 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray17, charArray18);
org.junit.Assert.assertArrayEquals(charArray15, charArray18);
char[] charArray21 = new char[] {};
char[] charArray22 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray21, charArray22);
char[] charArray24 = new char[] {};
char[] charArray25 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray24, charArray25);
org.junit.Assert.assertArrayEquals(charArray22, charArray25);
org.junit.Assert.assertArrayEquals("random", charArray15, charArray22);
char[] charArray29 = new char[] {};
char[] charArray30 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray29, charArray30);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", charArray22, charArray30);
org.junit.Assert.assertNotSame("tests.awaitsfix", (java.lang.Object) kuromojiAnalysisTests3, (java.lang.Object) charArray22);
char[] charArray35 = new char[] {};
char[] charArray36 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray35, charArray36);
char[] charArray38 = new char[] {};
char[] charArray39 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray38, charArray39);
org.junit.Assert.assertArrayEquals(charArray36, charArray39);
char[] charArray44 = new char[] {};
char[] charArray45 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray44, charArray45);
char[] charArray47 = new char[] {};
char[] charArray48 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray47, charArray48);
org.junit.Assert.assertArrayEquals(charArray45, charArray48);
char[] charArray51 = new char[] {};
char[] charArray52 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray51, charArray52);
char[] charArray54 = new char[] {};
char[] charArray55 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray54, charArray55);
org.junit.Assert.assertArrayEquals(charArray52, charArray55);
org.junit.Assert.assertArrayEquals("random", charArray45, charArray52);
char[] charArray59 = new char[] {};
char[] charArray60 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray59, charArray60);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", charArray52, charArray60);
org.junit.Assert.assertArrayEquals(charArray39, charArray60);
char[] charArray66 = new char[] {};
char[] charArray67 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray66, charArray67);
char[] charArray69 = new char[] {};
char[] charArray70 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray69, charArray70);
org.junit.Assert.assertArrayEquals(charArray67, charArray70);
char[] charArray73 = new char[] {};
char[] charArray74 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray73, charArray74);
char[] charArray76 = new char[] {};
char[] charArray77 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray76, charArray77);
org.junit.Assert.assertArrayEquals(charArray74, charArray77);
org.junit.Assert.assertArrayEquals("random", charArray67, charArray74);
char[] charArray81 = new char[] {};
char[] charArray82 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray81, charArray82);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", charArray74, charArray82);
org.junit.Assert.assertArrayEquals("tests.nightly", charArray60, charArray82);
org.junit.Assert.assertArrayEquals(charArray22, charArray60);
char[] charArray87 = new char[] {};
char[] charArray88 = new char[] {};
org.junit.Assert.assertArrayEquals(charArray87, charArray88);
org.junit.Assert.assertArrayEquals(charArray22, charArray88);
org.apache.lucene.document.FieldType fieldType91 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.document.Field field92 = org.apache.lucene.util.LuceneTestCase.newField(random0, "<unknown>", (java.lang.Object) charArray22, fieldType91);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(charArray14);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray14), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray14), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray14), "[]");
org.junit.Assert.assertNotNull(charArray15);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray15), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray15), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray15), "[]");
org.junit.Assert.assertNotNull(charArray17);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray17), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray17), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray17), "[]");
org.junit.Assert.assertNotNull(charArray18);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray18), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray18), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray18), "[]");
org.junit.Assert.assertNotNull(charArray21);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray21), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray21), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray21), "[]");
org.junit.Assert.assertNotNull(charArray22);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray22), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray22), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray22), "[]");
org.junit.Assert.assertNotNull(charArray24);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray24), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray24), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray24), "[]");
org.junit.Assert.assertNotNull(charArray25);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray25), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray25), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray25), "[]");
org.junit.Assert.assertNotNull(charArray29);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray29), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray29), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray29), "[]");
org.junit.Assert.assertNotNull(charArray30);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray30), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray30), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray30), "[]");
org.junit.Assert.assertNotNull(charArray35);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray35), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray35), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray35), "[]");
org.junit.Assert.assertNotNull(charArray36);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray36), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray36), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray36), "[]");
org.junit.Assert.assertNotNull(charArray38);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray38), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray38), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray38), "[]");
org.junit.Assert.assertNotNull(charArray39);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray39), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray39), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray39), "[]");
org.junit.Assert.assertNotNull(charArray44);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray44), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray44), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray44), "[]");
org.junit.Assert.assertNotNull(charArray45);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray45), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray45), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray45), "[]");
org.junit.Assert.assertNotNull(charArray47);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray47), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray47), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray47), "[]");
org.junit.Assert.assertNotNull(charArray48);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray48), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray48), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray48), "[]");
org.junit.Assert.assertNotNull(charArray51);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray51), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray51), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray51), "[]");
org.junit.Assert.assertNotNull(charArray52);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray52), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray52), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray52), "[]");
org.junit.Assert.assertNotNull(charArray54);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray54), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray54), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray54), "[]");
org.junit.Assert.assertNotNull(charArray55);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray55), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray55), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray55), "[]");
org.junit.Assert.assertNotNull(charArray59);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray59), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray59), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray59), "[]");
org.junit.Assert.assertNotNull(charArray60);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray60), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray60), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray60), "[]");
org.junit.Assert.assertNotNull(charArray66);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray66), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray66), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray66), "[]");
org.junit.Assert.assertNotNull(charArray67);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray67), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray67), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray67), "[]");
org.junit.Assert.assertNotNull(charArray69);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray69), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray69), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray69), "[]");
org.junit.Assert.assertNotNull(charArray70);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray70), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray70), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray70), "[]");
org.junit.Assert.assertNotNull(charArray73);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray73), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray73), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray73), "[]");
org.junit.Assert.assertNotNull(charArray74);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray74), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray74), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray74), "[]");
org.junit.Assert.assertNotNull(charArray76);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray76), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray76), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray76), "[]");
org.junit.Assert.assertNotNull(charArray77);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray77), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray77), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray77), "[]");
org.junit.Assert.assertNotNull(charArray81);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray81), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray81), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray81), "[]");
org.junit.Assert.assertNotNull(charArray82);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray82), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray82), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray82), "[]");
org.junit.Assert.assertNotNull(charArray87);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray87), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray87), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray87), "[]");
org.junit.Assert.assertNotNull(charArray88);
org.junit.Assert.assertEquals(java.lang.String.copyValueOf(charArray88), "");
org.junit.Assert.assertEquals(java.lang.String.valueOf(charArray88), "");
org.junit.Assert.assertEquals(java.util.Arrays.toString(charArray88), "[]");
}
@Test
public void test17634() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17634");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("tests.weekly", indexReader7, (int) (short) 1, postingsEnum9, postingsEnum10);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests12 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests12.tearDown();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Terms terms16 = null;
org.apache.lucene.index.Terms terms17 = null;
kuromojiAnalysisTests12.assertTermsEquals("tests.failfast", indexReader15, terms16, terms17, false);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests12.assertDocsSkippingEquals("tests.nightly", indexReader21, (int) (byte) -1, postingsEnum23, postingsEnum24, false);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
kuromojiAnalysisTests12.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader28, (int) (short) -1, postingsEnum30, postingsEnum31);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests34 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule35 = kuromojiAnalysisTests34.ruleChain;
kuromojiAnalysisTests34.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests34);
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests34.failureAndSuccessEvents;
kuromojiAnalysisTests12.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.tearDown();
org.junit.Assert.assertNotNull("hi!", (java.lang.Object) kuromojiAnalysisTests2);
kuromojiAnalysisTests2.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Fields fields46 = null;
org.apache.lucene.index.Fields fields47 = null;
kuromojiAnalysisTests2.assertFieldsEquals("", indexReader45, fields46, fields47, true);
org.apache.lucene.index.IndexReader indexReader51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum53 = null;
org.apache.lucene.index.PostingsEnum postingsEnum54 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("tests.weekly", indexReader51, (int) '#', postingsEnum53, postingsEnum54);
org.apache.lucene.index.IndexReader indexReader57 = null;
org.apache.lucene.index.Fields fields58 = null;
org.apache.lucene.index.Fields fields59 = null;
kuromojiAnalysisTests2.assertFieldsEquals("<unknown>", indexReader57, fields58, fields59, false);
org.junit.Assert.assertNotNull(testRule3);
org.junit.Assert.assertNotNull(testRule35);
org.junit.Assert.assertNotNull(ruleChain38);
}
@Test
public void test17635() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17635");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Terms terms14 = null;
org.apache.lucene.index.Terms terms15 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader13, terms14, terms15, false);
org.apache.lucene.index.IndexReader indexReader19 = null;
org.apache.lucene.index.Terms terms20 = null;
org.apache.lucene.index.Terms terms21 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.badapples", indexReader19, terms20, terms21, true);
kuromojiAnalysisTests1.assertPathHasBeenCleared("tests.weekly");
kuromojiAnalysisTests1.resetCheckIndexStatus();
org.junit.Assert.assertNotNull(testRule2);
}
@Test
public void test17636() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17636");
org.junit.Assert.assertEquals("tests.monster", (float) (-1), (float) 1L, (float) 2);
}
@Test
public void test17637() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17637");
// The following exception was thrown during execution in test generation
try {
int int2 = org.elasticsearch.test.ESTestCase.scaledRandomIntBetween((int) 'a', (int) (byte) 100);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17638() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17638");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
org.apache.lucene.index.IndexReader indexReader18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.monster", indexReader18, (int) (byte) 1, postingsEnum20, postingsEnum21);
org.apache.lucene.index.IndexReader indexReader24 = null;
org.apache.lucene.index.Fields fields25 = null;
org.apache.lucene.index.Fields fields26 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.weekly", indexReader24, fields25, fields26, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService31 = kuromojiAnalysisTests0.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17639() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17639");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.nightly", indexReader20, 0, postingsEnum22, postingsEnum23);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.IndexReader indexReader29 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderEquals("<unknown>", indexReader28, indexReader29);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17640() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17640");
double[] doubleArray1 = new double[] {};
double[] doubleArray2 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray1, doubleArray2, (double) '4');
double[] doubleArray5 = new double[] {};
double[] doubleArray6 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray5, doubleArray6, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray2, doubleArray6, (double) (byte) -1);
double[] doubleArray11 = new double[] {};
double[] doubleArray12 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray11, doubleArray12, (double) '4');
double[] doubleArray15 = new double[] {};
double[] doubleArray16 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray15, doubleArray16, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray11, doubleArray16, (double) (short) 10);
org.junit.Assert.assertArrayEquals(doubleArray2, doubleArray11, (double) 100);
double[] doubleArray25 = new double[] {};
double[] doubleArray26 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray25, doubleArray26, (double) '4');
double[] doubleArray29 = new double[] {};
double[] doubleArray30 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray29, doubleArray30, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray25, doubleArray30, (double) (short) 10);
double[] doubleArray35 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray25, doubleArray35, (double) 10L);
double[] doubleArray38 = new double[] {};
double[] doubleArray39 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray38, doubleArray39, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray35, doubleArray39, (double) (byte) 1);
double[] doubleArray45 = new double[] {};
double[] doubleArray46 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray45, doubleArray46, (double) '4');
double[] doubleArray49 = new double[] {};
double[] doubleArray50 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray49, doubleArray50, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray45, doubleArray50, (double) (short) 10);
double[] doubleArray55 = new double[] {};
double[] doubleArray56 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray55, doubleArray56, (double) '4');
double[] doubleArray59 = new double[] {};
double[] doubleArray60 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray59, doubleArray60, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray55, doubleArray60, (double) (short) 10);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", doubleArray50, doubleArray55, (double) 4);
org.junit.Assert.assertArrayEquals("", doubleArray39, doubleArray55, (double) 0L);
double[] doubleArray70 = new double[] {};
double[] doubleArray71 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray70, doubleArray71, (double) '4');
double[] doubleArray74 = new double[] {};
double[] doubleArray75 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray74, doubleArray75, (double) '4');
org.junit.Assert.assertArrayEquals(doubleArray71, doubleArray75, (double) (byte) -1);
double[] doubleArray80 = new double[] {};
double[] doubleArray81 = new double[] {};
org.junit.Assert.assertArrayEquals(doubleArray80, doubleArray81, (double) '4');
org.junit.Assert.assertArrayEquals("tests.failfast", doubleArray71, doubleArray81, (double) 0);
org.junit.Assert.assertArrayEquals("tests.awaitsfix", doubleArray55, doubleArray81, 0.0d);
org.junit.Assert.assertArrayEquals("", doubleArray11, doubleArray81, (double) 3);
org.junit.Assert.assertNotNull(doubleArray1);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray1), "[]");
org.junit.Assert.assertNotNull(doubleArray2);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray2), "[]");
org.junit.Assert.assertNotNull(doubleArray5);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray5), "[]");
org.junit.Assert.assertNotNull(doubleArray6);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray6), "[]");
org.junit.Assert.assertNotNull(doubleArray11);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray11), "[]");
org.junit.Assert.assertNotNull(doubleArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray12), "[]");
org.junit.Assert.assertNotNull(doubleArray15);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray15), "[]");
org.junit.Assert.assertNotNull(doubleArray16);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray16), "[]");
org.junit.Assert.assertNotNull(doubleArray25);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray25), "[]");
org.junit.Assert.assertNotNull(doubleArray26);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray26), "[]");
org.junit.Assert.assertNotNull(doubleArray29);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray29), "[]");
org.junit.Assert.assertNotNull(doubleArray30);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray30), "[]");
org.junit.Assert.assertNotNull(doubleArray35);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray35), "[]");
org.junit.Assert.assertNotNull(doubleArray38);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray38), "[]");
org.junit.Assert.assertNotNull(doubleArray39);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray39), "[]");
org.junit.Assert.assertNotNull(doubleArray45);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray45), "[]");
org.junit.Assert.assertNotNull(doubleArray46);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray46), "[]");
org.junit.Assert.assertNotNull(doubleArray49);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray49), "[]");
org.junit.Assert.assertNotNull(doubleArray50);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray50), "[]");
org.junit.Assert.assertNotNull(doubleArray55);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray55), "[]");
org.junit.Assert.assertNotNull(doubleArray56);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray56), "[]");
org.junit.Assert.assertNotNull(doubleArray59);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray59), "[]");
org.junit.Assert.assertNotNull(doubleArray60);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray60), "[]");
org.junit.Assert.assertNotNull(doubleArray70);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray70), "[]");
org.junit.Assert.assertNotNull(doubleArray71);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray71), "[]");
org.junit.Assert.assertNotNull(doubleArray74);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray74), "[]");
org.junit.Assert.assertNotNull(doubleArray75);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray75), "[]");
org.junit.Assert.assertNotNull(doubleArray80);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray80), "[]");
org.junit.Assert.assertNotNull(doubleArray81);
org.junit.Assert.assertEquals(java.util.Arrays.toString(doubleArray81), "[]");
}
@Test
public void test17641() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17641");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.setUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests10 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule11 = kuromojiAnalysisTests10.ruleChain;
kuromojiAnalysisTests10.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests10.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests10.assertDocsEnumEquals("<unknown>", postingsEnum15, postingsEnum16, true);
kuromojiAnalysisTests10.ensureAllSearchContextsReleased();
java.lang.Class<?> wildcardClass20 = kuromojiAnalysisTests10.getClass();
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) kuromojiAnalysisTests10);
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
org.apache.lucene.index.PostingsEnum postingsEnum26 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.badapples", indexReader23, 100, postingsEnum25, postingsEnum26);
org.junit.rules.TestRule testRule28 = kuromojiAnalysisTests0.ruleChain;
org.junit.Assert.assertNotNull(testRule11);
org.junit.Assert.assertNotNull(wildcardClass20);
org.junit.Assert.assertNotNull(testRule28);
}
@Test
public void test17642() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17642");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("random", indexReader16, (int) ' ', postingsEnum18, postingsEnum19, true);
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
org.apache.lucene.index.PostingsEnum postingsEnum26 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader23, (-1), postingsEnum25, postingsEnum26, false);
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) -1);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
org.junit.rules.RuleChain ruleChain32 = null;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain32;
org.apache.lucene.index.IndexReader indexReader35 = null;
org.apache.lucene.index.IndexReader indexReader36 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderEquals("europarl.lines.txt.gz", indexReader35, indexReader36);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test17643() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17643");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
kuromojiAnalysisTests1.setUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests17 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests17.tearDown();
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.Fields fields21 = null;
org.apache.lucene.index.Fields fields22 = null;
kuromojiAnalysisTests17.assertFieldsEquals("enwiki.random.lines.txt", indexReader20, fields21, fields22, true);
kuromojiAnalysisTests17.setUp();
kuromojiAnalysisTests17.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.Fields fields30 = null;
org.apache.lucene.index.Fields fields31 = null;
kuromojiAnalysisTests17.assertFieldsEquals("enwiki.random.lines.txt", indexReader29, fields30, fields31, false);
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests17.ruleChain;
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
kuromojiAnalysisTests17.assertDocsSkippingEquals("tests.weekly", indexReader36, 1, postingsEnum38, postingsEnum39, false);
kuromojiAnalysisTests17.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.Fields fields45 = null;
org.apache.lucene.index.Fields fields46 = null;
kuromojiAnalysisTests17.assertFieldsEquals("tests.monster", indexReader44, fields45, fields46, true);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests49 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests49.tearDown();
org.apache.lucene.index.IndexReader indexReader52 = null;
org.apache.lucene.index.Terms terms53 = null;
org.apache.lucene.index.Terms terms54 = null;
kuromojiAnalysisTests49.assertTermsEquals("tests.failfast", indexReader52, terms53, terms54, false);
org.apache.lucene.index.IndexReader indexReader58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum60 = null;
org.apache.lucene.index.PostingsEnum postingsEnum61 = null;
kuromojiAnalysisTests49.assertDocsSkippingEquals("tests.nightly", indexReader58, (int) (byte) -1, postingsEnum60, postingsEnum61, false);
org.apache.lucene.index.IndexReader indexReader65 = null;
org.apache.lucene.index.PostingsEnum postingsEnum67 = null;
org.apache.lucene.index.PostingsEnum postingsEnum68 = null;
kuromojiAnalysisTests49.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader65, (int) (short) -1, postingsEnum67, postingsEnum68);
org.junit.rules.RuleChain ruleChain70 = kuromojiAnalysisTests49.failureAndSuccessEvents;
kuromojiAnalysisTests17.failureAndSuccessEvents = ruleChain70;
org.junit.Assert.assertNotSame("tests.failfast", (java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) kuromojiAnalysisTests17);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain70);
}
@Test
public void test17644() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17644");
org.junit.Assert.assertNotEquals("", 100.0d, (double) 1L, 0.0d);
}
@Test
public void test17645() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17645");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.assertPathHasBeenCleared("enwiki.random.lines.txt");
kuromojiAnalysisTests0.setIndexWriterMaxDocs((-1));
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '4');
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 0);
kuromojiAnalysisTests0.resetCheckIndexStatus();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment18 = kuromojiAnalysisTests0.newNodeEnvironment();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17646() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17646");
// The following exception was thrown during execution in test generation
try {
int int2 = org.elasticsearch.test.ESTestCase.between((-1), (int) '#');
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17647() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17647");
byte[] byteArray3 = new byte[] {};
byte[] byteArray4 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray3, byteArray4);
byte[] byteArray8 = new byte[] {};
byte[] byteArray9 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray8, byteArray9);
byte[] byteArray12 = new byte[] {};
byte[] byteArray13 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray12, byteArray13);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray8, byteArray12);
byte[] byteArray18 = new byte[] {};
byte[] byteArray19 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray18, byteArray19);
byte[] byteArray22 = new byte[] {};
byte[] byteArray23 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray22, byteArray23);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray18, byteArray22);
org.junit.Assert.assertArrayEquals(byteArray12, byteArray18);
org.junit.Assert.assertArrayEquals("", byteArray3, byteArray12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests28 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests28.tearDown();
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests28.assertTermsEquals("tests.failfast", indexReader31, terms32, terms33, false);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests28.assertDocsSkippingEquals("tests.nightly", indexReader37, (int) (byte) -1, postingsEnum39, postingsEnum40, false);
org.junit.rules.RuleChain ruleChain43 = kuromojiAnalysisTests28.failureAndSuccessEvents;
kuromojiAnalysisTests28.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests46 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule47 = kuromojiAnalysisTests46.ruleChain;
kuromojiAnalysisTests46.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests46);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests46.failureAndSuccessEvents;
kuromojiAnalysisTests46.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests28, (java.lang.Object) kuromojiAnalysisTests46);
org.junit.Assert.assertNotEquals("tests.maxfailures", (java.lang.Object) byteArray12, (java.lang.Object) kuromojiAnalysisTests46);
kuromojiAnalysisTests46.tearDown();
org.junit.Assert.assertNotNull(byteArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray3), "[]");
org.junit.Assert.assertNotNull(byteArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray4), "[]");
org.junit.Assert.assertNotNull(byteArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray8), "[]");
org.junit.Assert.assertNotNull(byteArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray9), "[]");
org.junit.Assert.assertNotNull(byteArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray12), "[]");
org.junit.Assert.assertNotNull(byteArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray13), "[]");
org.junit.Assert.assertNotNull(byteArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray18), "[]");
org.junit.Assert.assertNotNull(byteArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray19), "[]");
org.junit.Assert.assertNotNull(byteArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray22), "[]");
org.junit.Assert.assertNotNull(byteArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray23), "[]");
org.junit.Assert.assertNotNull(ruleChain43);
org.junit.Assert.assertNotNull(testRule47);
org.junit.Assert.assertNotNull(ruleChain50);
}
@Test
public void test17648() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17648");
// The following exception was thrown during execution in test generation
try {
int int2 = org.elasticsearch.test.ESTestCase.scaledRandomIntBetween((int) (short) 1, (int) (byte) 0);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: max must be >= min: 1, 0");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
}
@Test
public void test17649() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17649");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.rules.TestRule testRule4 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("europarl.lines.txt.gz");
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.Terms terms10 = null;
org.apache.lucene.index.Terms terms11 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader9, terms10, terms11, true);
java.lang.String[][][][][] strArray14 = new java.lang.String[][][][][] {};
java.util.Set<java.lang.String[][][][]> strArraySet15 = org.apache.lucene.util.LuceneTestCase.asSet(strArray14);
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) strArray14);
java.util.Set<java.lang.String[][][][]> strArraySet17 = org.apache.lucene.util.LuceneTestCase.asSet(strArray14);
java.util.Set<java.io.Serializable[]> serializableArraySet18 = org.apache.lucene.util.LuceneTestCase.asSet((java.io.Serializable[][]) strArray14);
org.junit.Assert.assertNotNull(testRule4);
org.junit.Assert.assertNotNull(strArray14);
org.junit.Assert.assertNotNull(strArraySet15);
org.junit.Assert.assertNotNull(strArraySet17);
org.junit.Assert.assertNotNull(serializableArraySet18);
}
@Test
public void test17650() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17650");
byte[] byteArray3 = new byte[] {};
byte[] byteArray4 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray3, byteArray4);
byte[] byteArray8 = new byte[] {};
byte[] byteArray9 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray8, byteArray9);
byte[] byteArray12 = new byte[] {};
byte[] byteArray13 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray12, byteArray13);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray8, byteArray12);
byte[] byteArray18 = new byte[] {};
byte[] byteArray19 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray18, byteArray19);
byte[] byteArray22 = new byte[] {};
byte[] byteArray23 = new byte[] {};
org.junit.Assert.assertArrayEquals("tests.failfast", byteArray22, byteArray23);
org.junit.Assert.assertArrayEquals("tests.monster", byteArray18, byteArray22);
org.junit.Assert.assertArrayEquals(byteArray12, byteArray18);
org.junit.Assert.assertArrayEquals("", byteArray3, byteArray12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests28 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests28.tearDown();
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests28.assertTermsEquals("tests.failfast", indexReader31, terms32, terms33, false);
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests28.assertDocsSkippingEquals("tests.nightly", indexReader37, (int) (byte) -1, postingsEnum39, postingsEnum40, false);
org.junit.rules.RuleChain ruleChain43 = kuromojiAnalysisTests28.failureAndSuccessEvents;
kuromojiAnalysisTests28.resetCheckIndexStatus();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests46 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule47 = kuromojiAnalysisTests46.ruleChain;
kuromojiAnalysisTests46.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests46);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests46.failureAndSuccessEvents;
kuromojiAnalysisTests46.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests28, (java.lang.Object) kuromojiAnalysisTests46);
org.junit.Assert.assertNotEquals("tests.maxfailures", (java.lang.Object) byteArray12, (java.lang.Object) kuromojiAnalysisTests46);
org.apache.lucene.index.IndexReader indexReader55 = null;
org.apache.lucene.index.PostingsEnum postingsEnum57 = null;
org.apache.lucene.index.PostingsEnum postingsEnum58 = null;
kuromojiAnalysisTests46.assertPositionsSkippingEquals("tests.badapples", indexReader55, (int) ' ', postingsEnum57, postingsEnum58);
org.apache.lucene.index.IndexReader indexReader61 = null;
org.apache.lucene.index.PostingsEnum postingsEnum63 = null;
org.apache.lucene.index.PostingsEnum postingsEnum64 = null;
kuromojiAnalysisTests46.assertDocsSkippingEquals("tests.failfast", indexReader61, (int) (short) -1, postingsEnum63, postingsEnum64, false);
org.apache.lucene.index.IndexReader indexReader68 = null;
org.apache.lucene.index.IndexReader indexReader69 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests46.assertDeletedDocsEquals("tests.slow", indexReader68, indexReader69);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(byteArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray3), "[]");
org.junit.Assert.assertNotNull(byteArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray4), "[]");
org.junit.Assert.assertNotNull(byteArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray8), "[]");
org.junit.Assert.assertNotNull(byteArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray9), "[]");
org.junit.Assert.assertNotNull(byteArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray12), "[]");
org.junit.Assert.assertNotNull(byteArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray13), "[]");
org.junit.Assert.assertNotNull(byteArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray18), "[]");
org.junit.Assert.assertNotNull(byteArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray19), "[]");
org.junit.Assert.assertNotNull(byteArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray22), "[]");
org.junit.Assert.assertNotNull(byteArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(byteArray23), "[]");
org.junit.Assert.assertNotNull(ruleChain43);
org.junit.Assert.assertNotNull(testRule47);
org.junit.Assert.assertNotNull(ruleChain50);
}
@Test
public void test17651() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17651");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) (-1));
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.badapples", indexReader8, (int) ' ', postingsEnum10, postingsEnum11);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.assertPathHasBeenCleared("<unknown>");
org.junit.Assert.assertNotNull("", (java.lang.Object) kuromojiAnalysisTests1);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests1.ruleChain;
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule17);
}
@Test
public void test17652() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17652");
org.junit.rules.TestRule testRule0 = null;
org.junit.rules.RuleChain ruleChain1 = org.junit.rules.RuleChain.outerRule(testRule0);
org.junit.rules.RuleChain ruleChain2 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain1);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests3.tearDown();
kuromojiAnalysisTests3.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests3.tearDown();
kuromojiAnalysisTests3.overrideTestDefaultQueryCache();
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests3.assertPositionsSkippingEquals("tests.nightly", indexReader9, (int) ' ', postingsEnum11, postingsEnum12);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests14 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule15 = kuromojiAnalysisTests14.ruleChain;
org.apache.lucene.util.LuceneTestCase.classRules = testRule15;
org.apache.lucene.util.LuceneTestCase.classRules = testRule15;
org.junit.rules.RuleChain ruleChain18 = org.junit.rules.RuleChain.outerRule(testRule15);
kuromojiAnalysisTests3.failureAndSuccessEvents = ruleChain18;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests20 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests20.tearDown();
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.Terms terms24 = null;
org.apache.lucene.index.Terms terms25 = null;
kuromojiAnalysisTests20.assertTermsEquals("tests.failfast", indexReader23, terms24, terms25, false);
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests20.assertDocsSkippingEquals("tests.nightly", indexReader29, (int) (byte) -1, postingsEnum31, postingsEnum32, false);
org.junit.rules.RuleChain ruleChain35 = kuromojiAnalysisTests20.failureAndSuccessEvents;
org.junit.rules.TestRule testRule36 = org.apache.lucene.util.LuceneTestCase.classRules;
org.apache.lucene.util.LuceneTestCase.classRules = testRule36;
org.junit.rules.RuleChain ruleChain38 = ruleChain35.around(testRule36);
org.junit.rules.RuleChain ruleChain39 = ruleChain18.around((org.junit.rules.TestRule) ruleChain38);
org.junit.rules.RuleChain ruleChain40 = ruleChain2.around((org.junit.rules.TestRule) ruleChain18);
org.junit.Assert.assertNotNull(ruleChain1);
org.junit.Assert.assertNotNull(ruleChain2);
org.junit.Assert.assertNotNull(testRule15);
org.junit.Assert.assertNotNull(ruleChain18);
org.junit.Assert.assertNotNull(ruleChain35);
org.junit.Assert.assertNotNull(testRule36);
org.junit.Assert.assertNotNull(ruleChain38);
org.junit.Assert.assertNotNull(ruleChain39);
org.junit.Assert.assertNotNull(ruleChain40);
}
@Test
public void test17653() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17653");
org.junit.Assert.assertNotEquals((long) 3, (long) (byte) -1);
}
@Test
public void test17654() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17654");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs(0);
kuromojiAnalysisTests0.resetCheckIndexStatus();
java.lang.Object obj15 = null;
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, obj15);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 100);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.IndexReader indexReader22 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertFieldInfosEquals("tests.slow", indexReader21, indexReader22);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule17);
}
@Test
public void test17655() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17655");
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling0 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.NEVER;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
org.junit.rules.RuleChain ruleChain16 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.junit.rules.TestRule testRule17 = org.apache.lucene.util.LuceneTestCase.classRules;
org.apache.lucene.util.LuceneTestCase.classRules = testRule17;
org.junit.rules.RuleChain ruleChain19 = ruleChain16.around(testRule17);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain16;
org.junit.Assert.assertNotEquals((java.lang.Object) throttling0, (java.lang.Object) ruleChain16);
org.junit.rules.RuleChain ruleChain22 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain16);
org.junit.rules.RuleChain ruleChain23 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests25 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule26 = kuromojiAnalysisTests25.ruleChain;
kuromojiAnalysisTests25.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests25);
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.Terms terms31 = null;
org.apache.lucene.index.Terms terms32 = null;
kuromojiAnalysisTests25.assertTermsEquals("random", indexReader30, terms31, terms32, false);
org.junit.rules.RuleChain ruleChain35 = kuromojiAnalysisTests25.failureAndSuccessEvents;
org.junit.runners.model.Statement statement36 = null;
org.junit.runner.Description description37 = null;
org.junit.runners.model.Statement statement38 = ruleChain35.apply(statement36, description37);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests40 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule41 = kuromojiAnalysisTests40.ruleChain;
kuromojiAnalysisTests40.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests40);
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests40.assertTermsEquals("random", indexReader45, terms46, terms47, false);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests40.failureAndSuccessEvents;
org.junit.runners.model.Statement statement51 = null;
org.junit.runner.Description description52 = null;
org.junit.runners.model.Statement statement53 = ruleChain50.apply(statement51, description52);
org.junit.runner.Description description54 = null;
org.junit.runners.model.Statement statement55 = ruleChain35.apply(statement53, description54);
org.junit.runner.Description description56 = null;
org.junit.runners.model.Statement statement57 = ruleChain23.apply(statement53, description56);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests59 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule60 = kuromojiAnalysisTests59.ruleChain;
kuromojiAnalysisTests59.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests59);
org.apache.lucene.index.IndexReader indexReader64 = null;
org.apache.lucene.index.Terms terms65 = null;
org.apache.lucene.index.Terms terms66 = null;
kuromojiAnalysisTests59.assertTermsEquals("random", indexReader64, terms65, terms66, false);
org.junit.rules.RuleChain ruleChain69 = kuromojiAnalysisTests59.failureAndSuccessEvents;
org.junit.runners.model.Statement statement70 = null;
org.junit.runner.Description description71 = null;
org.junit.runners.model.Statement statement72 = ruleChain69.apply(statement70, description71);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests74 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule75 = kuromojiAnalysisTests74.ruleChain;
kuromojiAnalysisTests74.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests74);
org.apache.lucene.index.IndexReader indexReader79 = null;
org.apache.lucene.index.Terms terms80 = null;
org.apache.lucene.index.Terms terms81 = null;
kuromojiAnalysisTests74.assertTermsEquals("random", indexReader79, terms80, terms81, false);
org.junit.rules.RuleChain ruleChain84 = kuromojiAnalysisTests74.failureAndSuccessEvents;
org.junit.runners.model.Statement statement85 = null;
org.junit.runner.Description description86 = null;
org.junit.runners.model.Statement statement87 = ruleChain84.apply(statement85, description86);
org.junit.runner.Description description88 = null;
org.junit.runners.model.Statement statement89 = ruleChain69.apply(statement87, description88);
org.junit.runner.Description description90 = null;
org.junit.runners.model.Statement statement91 = ruleChain23.apply(statement89, description90);
org.junit.runner.Description description92 = null;
org.junit.runners.model.Statement statement93 = ruleChain16.apply(statement89, description92);
org.junit.rules.RuleChain ruleChain94 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain16);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain16;
org.junit.Assert.assertTrue("'" + throttling0 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.NEVER + "'", throttling0.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.NEVER));
org.junit.Assert.assertNotNull(ruleChain16);
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(ruleChain22);
org.junit.Assert.assertNotNull(ruleChain23);
org.junit.Assert.assertNotNull(testRule26);
org.junit.Assert.assertNotNull(ruleChain35);
org.junit.Assert.assertNotNull(statement38);
org.junit.Assert.assertNotNull(testRule41);
org.junit.Assert.assertNotNull(ruleChain50);
org.junit.Assert.assertNotNull(statement53);
org.junit.Assert.assertNotNull(statement55);
org.junit.Assert.assertNotNull(statement57);
org.junit.Assert.assertNotNull(testRule60);
org.junit.Assert.assertNotNull(ruleChain69);
org.junit.Assert.assertNotNull(statement72);
org.junit.Assert.assertNotNull(testRule75);
org.junit.Assert.assertNotNull(ruleChain84);
org.junit.Assert.assertNotNull(statement87);
org.junit.Assert.assertNotNull(statement89);
org.junit.Assert.assertNotNull(statement91);
org.junit.Assert.assertNotNull(statement93);
org.junit.Assert.assertNotNull(ruleChain94);
}
@Test
public void test17656() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17656");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests2.assertPositionsSkippingEquals("tests.weekly", indexReader7, (int) (short) 1, postingsEnum9, postingsEnum10);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests12 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests12.tearDown();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.Terms terms16 = null;
org.apache.lucene.index.Terms terms17 = null;
kuromojiAnalysisTests12.assertTermsEquals("tests.failfast", indexReader15, terms16, terms17, false);
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
kuromojiAnalysisTests12.assertDocsSkippingEquals("tests.nightly", indexReader21, (int) (byte) -1, postingsEnum23, postingsEnum24, false);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
kuromojiAnalysisTests12.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader28, (int) (short) -1, postingsEnum30, postingsEnum31);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests34 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule35 = kuromojiAnalysisTests34.ruleChain;
kuromojiAnalysisTests34.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests34);
org.junit.rules.RuleChain ruleChain38 = kuromojiAnalysisTests34.failureAndSuccessEvents;
kuromojiAnalysisTests12.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.failureAndSuccessEvents = ruleChain38;
kuromojiAnalysisTests2.tearDown();
org.junit.Assert.assertNotNull("hi!", (java.lang.Object) kuromojiAnalysisTests2);
kuromojiAnalysisTests2.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests2.assertTermsEquals("tests.monster", indexReader45, terms46, terms47, true);
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum52 = null;
kuromojiAnalysisTests2.assertDocsEnumEquals("tests.nightly", postingsEnum51, postingsEnum52, false);
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment55 = kuromojiAnalysisTests2.newNodeEnvironment();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule3);
org.junit.Assert.assertNotNull(testRule35);
org.junit.Assert.assertNotNull(ruleChain38);
}
@Test
public void test17657() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17657");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader5 = null;
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("europarl.lines.txt.gz", indexReader5, (int) (short) 100, postingsEnum7, postingsEnum8);
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Terms terms14 = null;
org.apache.lucene.index.Terms terms15 = null;
kuromojiAnalysisTests0.assertTermsEquals("enwiki.random.lines.txt", indexReader13, terms14, terms15, true);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests18 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests18.tearDown();
org.apache.lucene.index.IndexReader indexReader21 = null;
org.apache.lucene.index.Terms terms22 = null;
org.apache.lucene.index.Terms terms23 = null;
kuromojiAnalysisTests18.assertTermsEquals("tests.failfast", indexReader21, terms22, terms23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests18.assertDocsSkippingEquals("tests.nightly", indexReader27, (int) (byte) -1, postingsEnum29, postingsEnum30, false);
org.apache.lucene.index.IndexReader indexReader34 = null;
org.apache.lucene.index.PostingsEnum postingsEnum36 = null;
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
kuromojiAnalysisTests18.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader34, (int) (short) -1, postingsEnum36, postingsEnum37);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests40 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule41 = kuromojiAnalysisTests40.ruleChain;
kuromojiAnalysisTests40.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests40);
org.junit.rules.RuleChain ruleChain44 = kuromojiAnalysisTests40.failureAndSuccessEvents;
kuromojiAnalysisTests18.failureAndSuccessEvents = ruleChain44;
org.apache.lucene.index.IndexReader indexReader47 = null;
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
kuromojiAnalysisTests18.assertDocsSkippingEquals("tests.badapples", indexReader47, 0, postingsEnum49, postingsEnum50, true);
org.apache.lucene.index.IndexReader indexReader54 = null;
org.apache.lucene.index.Terms terms55 = null;
org.apache.lucene.index.Terms terms56 = null;
kuromojiAnalysisTests18.assertTermsEquals("random", indexReader54, terms55, terms56, false);
kuromojiAnalysisTests18.setUp();
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) kuromojiAnalysisTests18);
org.junit.Assert.assertNotNull(testRule41);
org.junit.Assert.assertNotNull(ruleChain44);
}
@Test
public void test17658() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17658");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Fields fields9 = null;
org.apache.lucene.index.Fields fields10 = null;
kuromojiAnalysisTests0.assertFieldsEquals("", indexReader8, fields9, fields10, false);
kuromojiAnalysisTests0.setUp();
org.junit.rules.TestRule testRule14 = kuromojiAnalysisTests0.ruleChain;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testKuromojiEmptyUserDict();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(testRule14);
}
@Test
public void test17659() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17659");
org.junit.Assert.assertNotEquals("tests.failfast", (double) 100, (double) (byte) 0, (double) (byte) 1);
}
@Test
public void test17660() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17660");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (short) 0);
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.slow");
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader37, (int) (short) 1, postingsEnum39, postingsEnum40, true);
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17661() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17661");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.assertPathHasBeenCleared("enwiki.random.lines.txt");
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader13, 3, postingsEnum15, postingsEnum16, false);
java.lang.String str19 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.resetCheckIndexStatus();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testKuromojiEmptyUserDict();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "<unknown>" + "'", str19, "<unknown>");
}
@Test
public void test17662() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17662");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.Terms terms17 = null;
org.apache.lucene.index.Terms terms18 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader16, terms17, terms18, true);
org.apache.lucene.index.IndexReader indexReader22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum24 = null;
org.apache.lucene.index.PostingsEnum postingsEnum25 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("<unknown>", indexReader22, (int) (byte) 100, postingsEnum24, postingsEnum25, false);
kuromojiAnalysisTests0.assertPathHasBeenCleared("random");
org.junit.rules.TestRule testRule30 = kuromojiAnalysisTests0.ruleChain;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests32 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests32.tearDown();
org.apache.lucene.index.IndexReader indexReader35 = null;
org.apache.lucene.index.Terms terms36 = null;
org.apache.lucene.index.Terms terms37 = null;
kuromojiAnalysisTests32.assertTermsEquals("tests.failfast", indexReader35, terms36, terms37, false);
org.apache.lucene.index.IndexReader indexReader41 = null;
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
kuromojiAnalysisTests32.assertDocsSkippingEquals("tests.nightly", indexReader41, (int) (byte) -1, postingsEnum43, postingsEnum44, false);
org.junit.rules.RuleChain ruleChain47 = kuromojiAnalysisTests32.failureAndSuccessEvents;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures48 = null;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures49 = org.apache.lucene.util.LuceneTestCase.replaceMaxFailureRule(testRuleIgnoreAfterMaxFailures48);
org.junit.rules.RuleChain ruleChain50 = ruleChain47.around((org.junit.rules.TestRule) testRuleIgnoreAfterMaxFailures49);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling52 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray53 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling52 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet54 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray53);
java.util.List<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingList55 = org.elasticsearch.test.ESTestCase.randomSubsetOf(0, throttlingArray53);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling56 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray57 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling56 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet58 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray57);
org.junit.Assert.assertEquals((java.lang.Object[]) throttlingArray53, (java.lang.Object[]) throttlingArray57);
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain47, (java.lang.Object) throttlingArray57);
org.junit.Assert.assertNotNull("tests.failfast", (java.lang.Object) ruleChain47);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain47;
org.junit.rules.RuleChain ruleChain63 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain47);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain63;
org.junit.Assert.assertNotNull(testRule30);
org.junit.Assert.assertNotNull(ruleChain47);
org.junit.Assert.assertNull(testRuleIgnoreAfterMaxFailures49);
org.junit.Assert.assertNotNull(ruleChain50);
org.junit.Assert.assertTrue("'" + throttling52 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling52.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray53);
org.junit.Assert.assertNotNull(throttlingSet54);
org.junit.Assert.assertNotNull(throttlingList55);
org.junit.Assert.assertTrue("'" + throttling56 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling56.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray57);
org.junit.Assert.assertNotNull(throttlingSet58);
org.junit.Assert.assertNotNull(ruleChain63);
}
@Test
public void test17663() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17663");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.apache.lucene.index.IndexReader indexReader2 = null;
org.apache.lucene.index.Terms terms3 = null;
org.apache.lucene.index.Terms terms4 = null;
kuromojiAnalysisTests0.assertTermsEquals("", indexReader2, terms3, terms4, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 10);
kuromojiAnalysisTests0.setUp();
java.lang.String str12 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader15 = null;
org.apache.lucene.index.IndexReader indexReader16 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderStatisticsEquals("europarl.lines.txt.gz", indexReader15, indexReader16);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "<unknown>" + "'", str12, "<unknown>");
}
@Test
public void test17664() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17664");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum14 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.awaitsfix", indexReader12, (-1), postingsEnum14, postingsEnum15);
kuromojiAnalysisTests1.setUp();
org.junit.rules.RuleChain ruleChain18 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum21 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("", postingsEnum20, postingsEnum21, true);
kuromojiAnalysisTests1.tearDown();
kuromojiAnalysisTests1.setUp();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.testJapaneseStopFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(ruleChain18);
}
@Test
public void test17665() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17665");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.Terms terms8 = null;
org.apache.lucene.index.Terms terms9 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.awaitsfix", indexReader7, terms8, terms9, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.assertPathHasBeenCleared("enwiki.random.lines.txt");
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.IndexReader indexReader17 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertReaderStatisticsEquals("", indexReader16, indexReader17);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17666() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17666");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
org.junit.rules.TestRule testRule17 = kuromojiAnalysisTests0.ruleChain;
java.lang.String str18 = kuromojiAnalysisTests0.getTestName();
org.junit.rules.RuleChain ruleChain19 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests20 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests20.tearDown();
kuromojiAnalysisTests20.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests20.ensureCleanedUp();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests20.ruleChain;
kuromojiAnalysisTests20.assertPathHasBeenCleared("europarl.lines.txt.gz");
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain19, (java.lang.Object) kuromojiAnalysisTests20);
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests20);
org.junit.rules.RuleChain ruleChain29 = kuromojiAnalysisTests20.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.Terms terms32 = null;
org.apache.lucene.index.Terms terms33 = null;
kuromojiAnalysisTests20.assertTermsEquals("enwiki.random.lines.txt", indexReader31, terms32, terms33, false);
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests20.assertDocsEnumEquals("tests.slow", postingsEnum37, postingsEnum38, true);
org.elasticsearch.common.settings.Settings settings41 = null;
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment42 = kuromojiAnalysisTests20.newNodeEnvironment(settings41);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "<unknown>" + "'", str18, "<unknown>");
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain29);
}
@Test
public void test17667() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17667");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Terms terms5 = null;
org.apache.lucene.index.Terms terms6 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.failfast", indexReader4, terms5, terms6, false);
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
org.apache.lucene.index.PostingsEnum postingsEnum13 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.nightly", indexReader10, (int) (byte) -1, postingsEnum12, postingsEnum13, false);
org.apache.lucene.index.IndexReader indexReader17 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
org.apache.lucene.index.PostingsEnum postingsEnum20 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader17, (int) (short) -1, postingsEnum19, postingsEnum20);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests23 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule24 = kuromojiAnalysisTests23.ruleChain;
kuromojiAnalysisTests23.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests23);
org.junit.rules.RuleChain ruleChain27 = kuromojiAnalysisTests23.failureAndSuccessEvents;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain27;
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
kuromojiAnalysisTests1.assertDocsSkippingEquals("tests.badapples", indexReader30, 0, postingsEnum32, postingsEnum33, true);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader38 = null;
org.apache.lucene.index.Fields fields39 = null;
org.apache.lucene.index.Fields fields40 = null;
kuromojiAnalysisTests1.assertFieldsEquals("europarl.lines.txt.gz", indexReader38, fields39, fields40, false);
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.Terms terms45 = null;
org.apache.lucene.index.Terms terms46 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader44, terms45, terms46, true);
org.apache.lucene.index.PostingsEnum postingsEnum50 = null;
org.apache.lucene.index.PostingsEnum postingsEnum51 = null;
kuromojiAnalysisTests1.assertDocsEnumEquals("tests.badapples", postingsEnum50, postingsEnum51, true);
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests1.setUp();
kuromojiAnalysisTests1.assertPathHasBeenCleared("tests.badapples");
org.junit.Assert.assertNotNull("tests.failfast", (java.lang.Object) kuromojiAnalysisTests1);
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.junit.rules.RuleChain ruleChain60 = kuromojiAnalysisTests1.failureAndSuccessEvents;
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService61 = kuromojiAnalysisTests1.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule24);
org.junit.Assert.assertNotNull(ruleChain27);
org.junit.Assert.assertNotNull(ruleChain60);
}
@Test
public void test17668() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17668");
org.junit.Assert.assertEquals("tests.maxfailures", (double) ' ', 100.0d, 100.0d);
}
@Test
public void test17669() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17669");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
org.junit.rules.RuleChain ruleChain11 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.Terms terms14 = null;
org.apache.lucene.index.Terms terms15 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader13, terms14, terms15, true);
kuromojiAnalysisTests1.ensureAllSearchContextsReleased();
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.Fields fields21 = null;
org.apache.lucene.index.Fields fields22 = null;
kuromojiAnalysisTests1.assertFieldsEquals("hi!", indexReader20, fields21, fields22, true);
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.Terms terms27 = null;
org.apache.lucene.index.Terms terms28 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader26, terms27, terms28, false);
kuromojiAnalysisTests1.ensureCleanedUp();
kuromojiAnalysisTests1.ensureCheckIndexPassed();
kuromojiAnalysisTests1.setIndexWriterMaxDocs(0);
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(ruleChain11);
}
@Test
public void test17670() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17670");
java.io.Serializable[] serializableArray2 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet3 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray2);
java.io.Serializable[] serializableArray5 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet6 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray5);
java.io.Serializable[] serializableArray7 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet8 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray7);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray5, (java.lang.Object[]) serializableArray7);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray2, (java.lang.Object[]) serializableArray7);
java.io.Serializable[] serializableArray12 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet13 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray12);
java.io.Serializable[] serializableArray15 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet16 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray15);
java.io.Serializable[] serializableArray17 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet18 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray17);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray15, (java.lang.Object[]) serializableArray17);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray12, (java.lang.Object[]) serializableArray17);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray2, (java.lang.Object[]) serializableArray12);
java.util.concurrent.ExecutorService[] executorServiceArray23 = new java.util.concurrent.ExecutorService[] {};
boolean boolean24 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray23);
java.io.Serializable[] serializableArray26 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet27 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray26);
java.io.Serializable[] serializableArray28 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet29 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray28);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray26, (java.lang.Object[]) serializableArray28);
org.junit.Assert.assertArrayEquals("tests.badapples", (java.lang.Object[]) executorServiceArray23, (java.lang.Object[]) serializableArray28);
boolean boolean32 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray23);
java.io.Serializable[] serializableArray36 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet37 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray36);
java.io.Serializable[] serializableArray39 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet40 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray39);
java.io.Serializable[] serializableArray41 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet42 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray41);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray39, (java.lang.Object[]) serializableArray41);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray41);
java.io.Serializable[] serializableArray46 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet47 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray46);
java.io.Serializable[] serializableArray49 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet50 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray49);
java.io.Serializable[] serializableArray51 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet52 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray51);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray49, (java.lang.Object[]) serializableArray51);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray46, (java.lang.Object[]) serializableArray51);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray46);
java.io.Serializable[] serializableArray57 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet58 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray57);
java.io.Serializable[] serializableArray59 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet60 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray59);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray57, (java.lang.Object[]) serializableArray59);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray57);
java.io.Serializable[] serializableArray65 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet66 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray65);
java.io.Serializable[] serializableArray68 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet69 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray68);
java.io.Serializable[] serializableArray70 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet71 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray70);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray68, (java.lang.Object[]) serializableArray70);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray65, (java.lang.Object[]) serializableArray70);
java.io.Serializable[] serializableArray75 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet76 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray75);
java.io.Serializable[] serializableArray78 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet79 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray78);
java.io.Serializable[] serializableArray80 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet81 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray80);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray78, (java.lang.Object[]) serializableArray80);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray75, (java.lang.Object[]) serializableArray80);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray65, (java.lang.Object[]) serializableArray75);
org.junit.Assert.assertEquals((java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray65);
java.io.Serializable[] serializableArray87 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet88 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray87);
java.io.Serializable[] serializableArray90 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet91 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray90);
java.io.Serializable[] serializableArray92 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet93 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray92);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray90, (java.lang.Object[]) serializableArray92);
org.junit.Assert.assertEquals("tests.badapples", (java.lang.Object[]) serializableArray87, (java.lang.Object[]) serializableArray92);
org.junit.Assert.assertArrayEquals("tests.maxfailures", (java.lang.Object[]) serializableArray36, (java.lang.Object[]) serializableArray87);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) executorServiceArray23, (java.lang.Object[]) serializableArray36);
boolean boolean98 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray23);
org.junit.Assert.assertEquals((java.lang.Object[]) serializableArray12, (java.lang.Object[]) executorServiceArray23);
org.junit.Assert.assertNotNull(serializableArray2);
org.junit.Assert.assertNotNull(serializableSet3);
org.junit.Assert.assertNotNull(serializableArray5);
org.junit.Assert.assertNotNull(serializableSet6);
org.junit.Assert.assertNotNull(serializableArray7);
org.junit.Assert.assertNotNull(serializableSet8);
org.junit.Assert.assertNotNull(serializableArray12);
org.junit.Assert.assertNotNull(serializableSet13);
org.junit.Assert.assertNotNull(serializableArray15);
org.junit.Assert.assertNotNull(serializableSet16);
org.junit.Assert.assertNotNull(serializableArray17);
org.junit.Assert.assertNotNull(serializableSet18);
org.junit.Assert.assertNotNull(executorServiceArray23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + true + "'", boolean24 == true);
org.junit.Assert.assertNotNull(serializableArray26);
org.junit.Assert.assertNotNull(serializableSet27);
org.junit.Assert.assertNotNull(serializableArray28);
org.junit.Assert.assertNotNull(serializableSet29);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + true + "'", boolean32 == true);
org.junit.Assert.assertNotNull(serializableArray36);
org.junit.Assert.assertNotNull(serializableSet37);
org.junit.Assert.assertNotNull(serializableArray39);
org.junit.Assert.assertNotNull(serializableSet40);
org.junit.Assert.assertNotNull(serializableArray41);
org.junit.Assert.assertNotNull(serializableSet42);
org.junit.Assert.assertNotNull(serializableArray46);
org.junit.Assert.assertNotNull(serializableSet47);
org.junit.Assert.assertNotNull(serializableArray49);
org.junit.Assert.assertNotNull(serializableSet50);
org.junit.Assert.assertNotNull(serializableArray51);
org.junit.Assert.assertNotNull(serializableSet52);
org.junit.Assert.assertNotNull(serializableArray57);
org.junit.Assert.assertNotNull(serializableSet58);
org.junit.Assert.assertNotNull(serializableArray59);
org.junit.Assert.assertNotNull(serializableSet60);
org.junit.Assert.assertNotNull(serializableArray65);
org.junit.Assert.assertNotNull(serializableSet66);
org.junit.Assert.assertNotNull(serializableArray68);
org.junit.Assert.assertNotNull(serializableSet69);
org.junit.Assert.assertNotNull(serializableArray70);
org.junit.Assert.assertNotNull(serializableSet71);
org.junit.Assert.assertNotNull(serializableArray75);
org.junit.Assert.assertNotNull(serializableSet76);
org.junit.Assert.assertNotNull(serializableArray78);
org.junit.Assert.assertNotNull(serializableSet79);
org.junit.Assert.assertNotNull(serializableArray80);
org.junit.Assert.assertNotNull(serializableSet81);
org.junit.Assert.assertNotNull(serializableArray87);
org.junit.Assert.assertNotNull(serializableSet88);
org.junit.Assert.assertNotNull(serializableArray90);
org.junit.Assert.assertNotNull(serializableSet91);
org.junit.Assert.assertNotNull(serializableArray92);
org.junit.Assert.assertNotNull(serializableSet93);
org.junit.Assert.assertTrue("'" + boolean98 + "' != '" + true + "'", boolean98 == true);
}
@Test
public void test17671() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17671");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.monster", postingsEnum9, postingsEnum10, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureCleanedUp();
java.io.Serializable[] serializableArray16 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet17 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray16);
java.io.Serializable[] serializableArray18 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet19 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray18);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray16, (java.lang.Object[]) serializableArray18);
java.util.concurrent.ExecutorService[] executorServiceArray21 = new java.util.concurrent.ExecutorService[] {};
boolean boolean22 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
boolean boolean23 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray16, (java.lang.Object[]) executorServiceArray21);
boolean boolean25 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) executorServiceArray21);
org.apache.lucene.index.IndexReader indexReader28 = null;
org.apache.lucene.index.Fields fields29 = null;
org.apache.lucene.index.Fields fields30 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.awaitsfix", indexReader28, fields29, fields30, true);
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertNotNull(serializableArray16);
org.junit.Assert.assertNotNull(serializableSet17);
org.junit.Assert.assertNotNull(serializableArray18);
org.junit.Assert.assertNotNull(serializableSet19);
org.junit.Assert.assertNotNull(executorServiceArray21);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + true + "'", boolean25 == true);
}
@Test
public void test17672() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17672");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader8 = null;
org.apache.lucene.index.Fields fields9 = null;
org.apache.lucene.index.Fields fields10 = null;
kuromojiAnalysisTests0.assertFieldsEquals("", indexReader8, fields9, fields10, false);
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum17 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader14, (int) 'a', postingsEnum16, postingsEnum17);
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.ensureCleanedUp();
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(testRule19);
}
@Test
public void test17673() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17673");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain16 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests18 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule19 = kuromojiAnalysisTests18.ruleChain;
kuromojiAnalysisTests18.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests18);
org.apache.lucene.index.IndexReader indexReader23 = null;
org.apache.lucene.index.Terms terms24 = null;
org.apache.lucene.index.Terms terms25 = null;
kuromojiAnalysisTests18.assertTermsEquals("random", indexReader23, terms24, terms25, false);
org.junit.rules.RuleChain ruleChain28 = kuromojiAnalysisTests18.failureAndSuccessEvents;
org.junit.runners.model.Statement statement29 = null;
org.junit.runner.Description description30 = null;
org.junit.runners.model.Statement statement31 = ruleChain28.apply(statement29, description30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.apache.lucene.index.IndexReader indexReader38 = null;
org.apache.lucene.index.Terms terms39 = null;
org.apache.lucene.index.Terms terms40 = null;
kuromojiAnalysisTests33.assertTermsEquals("random", indexReader38, terms39, terms40, false);
org.junit.rules.RuleChain ruleChain43 = kuromojiAnalysisTests33.failureAndSuccessEvents;
org.junit.runners.model.Statement statement44 = null;
org.junit.runner.Description description45 = null;
org.junit.runners.model.Statement statement46 = ruleChain43.apply(statement44, description45);
org.junit.runner.Description description47 = null;
org.junit.runners.model.Statement statement48 = ruleChain28.apply(statement46, description47);
org.junit.runner.Description description49 = null;
org.junit.runners.model.Statement statement50 = ruleChain16.apply(statement46, description49);
org.junit.runner.Description description51 = null;
org.junit.runners.model.Statement statement52 = ruleChain15.apply(statement46, description51);
org.junit.rules.RuleChain ruleChain53 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests55 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule56 = kuromojiAnalysisTests55.ruleChain;
kuromojiAnalysisTests55.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests55);
org.apache.lucene.index.IndexReader indexReader60 = null;
org.apache.lucene.index.Terms terms61 = null;
org.apache.lucene.index.Terms terms62 = null;
kuromojiAnalysisTests55.assertTermsEquals("random", indexReader60, terms61, terms62, false);
org.junit.rules.RuleChain ruleChain65 = kuromojiAnalysisTests55.failureAndSuccessEvents;
org.junit.runners.model.Statement statement66 = null;
org.junit.runner.Description description67 = null;
org.junit.runners.model.Statement statement68 = ruleChain65.apply(statement66, description67);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests70 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule71 = kuromojiAnalysisTests70.ruleChain;
kuromojiAnalysisTests70.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests70);
org.apache.lucene.index.IndexReader indexReader75 = null;
org.apache.lucene.index.Terms terms76 = null;
org.apache.lucene.index.Terms terms77 = null;
kuromojiAnalysisTests70.assertTermsEquals("random", indexReader75, terms76, terms77, false);
org.junit.rules.RuleChain ruleChain80 = kuromojiAnalysisTests70.failureAndSuccessEvents;
org.junit.runners.model.Statement statement81 = null;
org.junit.runner.Description description82 = null;
org.junit.runners.model.Statement statement83 = ruleChain80.apply(statement81, description82);
org.junit.runner.Description description84 = null;
org.junit.runners.model.Statement statement85 = ruleChain65.apply(statement83, description84);
org.junit.runner.Description description86 = null;
org.junit.runners.model.Statement statement87 = ruleChain53.apply(statement83, description86);
org.junit.runner.Description description88 = null;
org.junit.runners.model.Statement statement89 = ruleChain15.apply(statement83, description88);
org.junit.rules.RuleChain ruleChain90 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain15);
org.junit.rules.RuleChain ruleChain91 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain15);
org.junit.rules.RuleChain ruleChain92 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain91);
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(ruleChain16);
org.junit.Assert.assertNotNull(testRule19);
org.junit.Assert.assertNotNull(ruleChain28);
org.junit.Assert.assertNotNull(statement31);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain43);
org.junit.Assert.assertNotNull(statement46);
org.junit.Assert.assertNotNull(statement48);
org.junit.Assert.assertNotNull(statement50);
org.junit.Assert.assertNotNull(statement52);
org.junit.Assert.assertNotNull(ruleChain53);
org.junit.Assert.assertNotNull(testRule56);
org.junit.Assert.assertNotNull(ruleChain65);
org.junit.Assert.assertNotNull(statement68);
org.junit.Assert.assertNotNull(testRule71);
org.junit.Assert.assertNotNull(ruleChain80);
org.junit.Assert.assertNotNull(statement83);
org.junit.Assert.assertNotNull(statement85);
org.junit.Assert.assertNotNull(statement87);
org.junit.Assert.assertNotNull(statement89);
org.junit.Assert.assertNotNull(ruleChain90);
org.junit.Assert.assertNotNull(ruleChain91);
org.junit.Assert.assertNotNull(ruleChain92);
}
@Test
public void test17674() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17674");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomRealisticUnicodeOfCodepointLengthBetween(5, 10);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17675() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17675");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomRealisticUnicodeOfLengthBetween((-1), 0);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17676() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17676");
java.util.concurrent.ExecutorService[] executorServiceArray0 = new java.util.concurrent.ExecutorService[] {};
boolean boolean1 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray0);
boolean boolean2 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray0);
boolean boolean3 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray0);
boolean boolean4 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray0);
java.io.Serializable[] serializableArray8 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet9 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray8);
java.io.Serializable[] serializableArray11 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet12 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray11);
java.io.Serializable[] serializableArray13 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet14 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray13);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray11, (java.lang.Object[]) serializableArray13);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray8, (java.lang.Object[]) serializableArray13);
java.io.Serializable[] serializableArray18 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet19 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray18);
java.io.Serializable[] serializableArray21 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet22 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray21);
java.io.Serializable[] serializableArray23 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet24 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray23);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray21, (java.lang.Object[]) serializableArray23);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray18, (java.lang.Object[]) serializableArray23);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray8, (java.lang.Object[]) serializableArray18);
java.io.Serializable[] serializableArray30 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet31 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray30);
java.io.Serializable[] serializableArray33 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet34 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray33);
java.io.Serializable[] serializableArray35 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet36 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray35);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray33, (java.lang.Object[]) serializableArray35);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray30, (java.lang.Object[]) serializableArray35);
java.io.Serializable[] serializableArray40 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet41 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray40);
java.io.Serializable[] serializableArray43 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet44 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray43);
java.io.Serializable[] serializableArray45 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet46 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray45);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray43, (java.lang.Object[]) serializableArray45);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray40, (java.lang.Object[]) serializableArray45);
org.junit.Assert.assertArrayEquals("random", (java.lang.Object[]) serializableArray30, (java.lang.Object[]) serializableArray40);
java.io.Serializable[] serializableArray51 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet52 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray51);
java.io.Serializable[] serializableArray53 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet54 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray53);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray51, (java.lang.Object[]) serializableArray53);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray30, (java.lang.Object[]) serializableArray51);
org.junit.Assert.assertEquals("tests.failfast", (java.lang.Object[]) serializableArray8, (java.lang.Object[]) serializableArray51);
org.junit.Assert.assertEquals((java.lang.Object[]) executorServiceArray0, (java.lang.Object[]) serializableArray51);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests59 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule60 = kuromojiAnalysisTests59.ruleChain;
kuromojiAnalysisTests59.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests59.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader64 = null;
org.apache.lucene.index.Fields fields65 = null;
org.apache.lucene.index.Fields fields66 = null;
kuromojiAnalysisTests59.assertFieldsEquals("tests.slow", indexReader64, fields65, fields66, true);
kuromojiAnalysisTests59.setUp();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests71 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests71.tearDown();
org.apache.lucene.index.IndexReader indexReader74 = null;
org.apache.lucene.index.Terms terms75 = null;
org.apache.lucene.index.Terms terms76 = null;
kuromojiAnalysisTests71.assertTermsEquals("tests.failfast", indexReader74, terms75, terms76, false);
org.apache.lucene.index.IndexReader indexReader80 = null;
org.apache.lucene.index.PostingsEnum postingsEnum82 = null;
org.apache.lucene.index.PostingsEnum postingsEnum83 = null;
kuromojiAnalysisTests71.assertDocsSkippingEquals("tests.nightly", indexReader80, (int) (byte) -1, postingsEnum82, postingsEnum83, false);
org.apache.lucene.index.IndexReader indexReader87 = null;
org.apache.lucene.index.PostingsEnum postingsEnum89 = null;
org.apache.lucene.index.PostingsEnum postingsEnum90 = null;
kuromojiAnalysisTests71.assertDocsSkippingEquals("random", indexReader87, (int) ' ', postingsEnum89, postingsEnum90, true);
org.junit.rules.TestRule testRule93 = null;
org.junit.rules.RuleChain ruleChain94 = org.junit.rules.RuleChain.outerRule(testRule93);
org.junit.rules.RuleChain ruleChain95 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain94);
org.junit.Assert.assertNotSame("tests.failfast", (java.lang.Object) indexReader87, (java.lang.Object) ruleChain95);
kuromojiAnalysisTests59.failureAndSuccessEvents = ruleChain95;
org.junit.Assert.assertNotSame((java.lang.Object) serializableArray51, (java.lang.Object) kuromojiAnalysisTests59);
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests59.testJapaneseStopFilterFactory();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(executorServiceArray0);
org.junit.Assert.assertTrue("'" + boolean1 + "' != '" + true + "'", boolean1 == true);
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
org.junit.Assert.assertTrue("'" + boolean3 + "' != '" + true + "'", boolean3 == true);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
org.junit.Assert.assertNotNull(serializableArray8);
org.junit.Assert.assertNotNull(serializableSet9);
org.junit.Assert.assertNotNull(serializableArray11);
org.junit.Assert.assertNotNull(serializableSet12);
org.junit.Assert.assertNotNull(serializableArray13);
org.junit.Assert.assertNotNull(serializableSet14);
org.junit.Assert.assertNotNull(serializableArray18);
org.junit.Assert.assertNotNull(serializableSet19);
org.junit.Assert.assertNotNull(serializableArray21);
org.junit.Assert.assertNotNull(serializableSet22);
org.junit.Assert.assertNotNull(serializableArray23);
org.junit.Assert.assertNotNull(serializableSet24);
org.junit.Assert.assertNotNull(serializableArray30);
org.junit.Assert.assertNotNull(serializableSet31);
org.junit.Assert.assertNotNull(serializableArray33);
org.junit.Assert.assertNotNull(serializableSet34);
org.junit.Assert.assertNotNull(serializableArray35);
org.junit.Assert.assertNotNull(serializableSet36);
org.junit.Assert.assertNotNull(serializableArray40);
org.junit.Assert.assertNotNull(serializableSet41);
org.junit.Assert.assertNotNull(serializableArray43);
org.junit.Assert.assertNotNull(serializableSet44);
org.junit.Assert.assertNotNull(serializableArray45);
org.junit.Assert.assertNotNull(serializableSet46);
org.junit.Assert.assertNotNull(serializableArray51);
org.junit.Assert.assertNotNull(serializableSet52);
org.junit.Assert.assertNotNull(serializableArray53);
org.junit.Assert.assertNotNull(serializableSet54);
org.junit.Assert.assertNotNull(testRule60);
org.junit.Assert.assertNotNull(ruleChain94);
org.junit.Assert.assertNotNull(ruleChain95);
}
@Test
public void test17677() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17677");
long[] longArray3 = new long[] { (byte) 0 };
long[] longArray5 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray3, longArray5);
long[] longArray8 = new long[] { (byte) 0 };
long[] longArray10 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray8, longArray10);
org.junit.Assert.assertArrayEquals("", longArray3, longArray10);
long[] longArray15 = new long[] { (byte) 0 };
long[] longArray17 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray15, longArray17);
long[] longArray20 = new long[] { (byte) 0 };
long[] longArray22 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray20, longArray22);
org.junit.Assert.assertArrayEquals(longArray15, longArray22);
long[] longArray26 = new long[] { (byte) 0 };
long[] longArray28 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray26, longArray28);
long[] longArray31 = new long[] { (byte) 0 };
long[] longArray33 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray31, longArray33);
org.junit.Assert.assertArrayEquals(longArray26, longArray33);
org.junit.Assert.assertArrayEquals("tests.maxfailures", longArray15, longArray26);
org.junit.Assert.assertArrayEquals(longArray10, longArray15);
long[] longArray39 = new long[] { (byte) 0 };
long[] longArray41 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray39, longArray41);
long[] longArray44 = new long[] { (byte) 0 };
long[] longArray46 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray44, longArray46);
org.junit.Assert.assertArrayEquals(longArray39, longArray46);
org.junit.Assert.assertArrayEquals(longArray10, longArray39);
long[] longArray52 = new long[] { (byte) 0 };
long[] longArray54 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray52, longArray54);
long[] longArray57 = new long[] { (byte) 0 };
long[] longArray59 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray57, longArray59);
org.junit.Assert.assertArrayEquals("", longArray52, longArray59);
long[] longArray64 = new long[] { (byte) 0 };
long[] longArray66 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray64, longArray66);
long[] longArray69 = new long[] { (byte) 0 };
long[] longArray71 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray69, longArray71);
org.junit.Assert.assertArrayEquals(longArray64, longArray71);
long[] longArray75 = new long[] { (byte) 0 };
long[] longArray77 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray75, longArray77);
long[] longArray80 = new long[] { (byte) 0 };
long[] longArray82 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray80, longArray82);
org.junit.Assert.assertArrayEquals(longArray75, longArray82);
org.junit.Assert.assertArrayEquals("tests.maxfailures", longArray64, longArray75);
org.junit.Assert.assertArrayEquals(longArray59, longArray64);
long[] longArray88 = new long[] { (byte) 0 };
long[] longArray90 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray88, longArray90);
org.junit.Assert.assertArrayEquals(longArray59, longArray88);
org.junit.Assert.assertArrayEquals("tests.awaitsfix", longArray10, longArray59);
org.junit.Assert.assertNotNull((java.lang.Object) longArray10);
org.junit.Assert.assertNotNull(longArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray3), "[0]");
org.junit.Assert.assertNotNull(longArray5);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray5), "[0]");
org.junit.Assert.assertNotNull(longArray8);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray8), "[0]");
org.junit.Assert.assertNotNull(longArray10);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray10), "[0]");
org.junit.Assert.assertNotNull(longArray15);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray15), "[0]");
org.junit.Assert.assertNotNull(longArray17);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray17), "[0]");
org.junit.Assert.assertNotNull(longArray20);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray20), "[0]");
org.junit.Assert.assertNotNull(longArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray22), "[0]");
org.junit.Assert.assertNotNull(longArray26);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray26), "[0]");
org.junit.Assert.assertNotNull(longArray28);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray28), "[0]");
org.junit.Assert.assertNotNull(longArray31);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray31), "[0]");
org.junit.Assert.assertNotNull(longArray33);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray33), "[0]");
org.junit.Assert.assertNotNull(longArray39);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray39), "[0]");
org.junit.Assert.assertNotNull(longArray41);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray41), "[0]");
org.junit.Assert.assertNotNull(longArray44);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray44), "[0]");
org.junit.Assert.assertNotNull(longArray46);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray46), "[0]");
org.junit.Assert.assertNotNull(longArray52);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray52), "[0]");
org.junit.Assert.assertNotNull(longArray54);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray54), "[0]");
org.junit.Assert.assertNotNull(longArray57);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray57), "[0]");
org.junit.Assert.assertNotNull(longArray59);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray59), "[0]");
org.junit.Assert.assertNotNull(longArray64);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray64), "[0]");
org.junit.Assert.assertNotNull(longArray66);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray66), "[0]");
org.junit.Assert.assertNotNull(longArray69);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray69), "[0]");
org.junit.Assert.assertNotNull(longArray71);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray71), "[0]");
org.junit.Assert.assertNotNull(longArray75);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray75), "[0]");
org.junit.Assert.assertNotNull(longArray77);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray77), "[0]");
org.junit.Assert.assertNotNull(longArray80);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray80), "[0]");
org.junit.Assert.assertNotNull(longArray82);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray82), "[0]");
org.junit.Assert.assertNotNull(longArray88);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray88), "[0]");
org.junit.Assert.assertNotNull(longArray90);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray90), "[0]");
}
@Test
public void test17678() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17678");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum10 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.monster", postingsEnum9, postingsEnum10, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureCleanedUp();
java.io.Serializable[] serializableArray16 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet17 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray16);
java.io.Serializable[] serializableArray18 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet19 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray18);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray16, (java.lang.Object[]) serializableArray18);
java.util.concurrent.ExecutorService[] executorServiceArray21 = new java.util.concurrent.ExecutorService[] {};
boolean boolean22 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
boolean boolean23 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) serializableArray16, (java.lang.Object[]) executorServiceArray21);
boolean boolean25 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray21);
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) executorServiceArray21);
org.junit.rules.TestRule testRule27 = kuromojiAnalysisTests0.ruleChain;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.Fields fields30 = null;
org.apache.lucene.index.Fields fields31 = null;
kuromojiAnalysisTests0.assertFieldsEquals("hi!", indexReader29, fields30, fields31, false);
org.apache.lucene.index.TermsEnum termsEnum35 = null;
org.apache.lucene.index.TermsEnum termsEnum36 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermStatsEquals("tests.nightly", termsEnum35, termsEnum36);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(serializableArray16);
org.junit.Assert.assertNotNull(serializableSet17);
org.junit.Assert.assertNotNull(serializableArray18);
org.junit.Assert.assertNotNull(serializableSet19);
org.junit.Assert.assertNotNull(executorServiceArray21);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + true + "'", boolean25 == true);
org.junit.Assert.assertNotNull(testRule27);
}
@Test
public void test17679() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17679");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests3 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests3.tearDown();
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests3.assertTermsEquals("tests.failfast", indexReader6, terms7, terms8, false);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Terms terms13 = null;
org.apache.lucene.index.Terms terms14 = null;
kuromojiAnalysisTests3.assertTermsEquals("", indexReader12, terms13, terms14, false);
org.junit.rules.RuleChain ruleChain17 = kuromojiAnalysisTests3.failureAndSuccessEvents;
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) kuromojiAnalysisTests3);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.Terms terms21 = null;
org.apache.lucene.index.Terms terms22 = null;
kuromojiAnalysisTests1.assertTermsEquals("tests.maxfailures", indexReader20, terms21, terms22, false);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests26 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule27 = kuromojiAnalysisTests26.ruleChain;
kuromojiAnalysisTests26.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests26);
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
org.apache.lucene.index.PostingsEnum postingsEnum34 = null;
kuromojiAnalysisTests26.assertPositionsSkippingEquals("tests.weekly", indexReader31, (int) (short) 1, postingsEnum33, postingsEnum34);
java.lang.String str36 = kuromojiAnalysisTests26.getTestName();
org.elasticsearch.index.analysis.KuromojiAnalysisTests[] kuromojiAnalysisTestsArray37 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests[] { kuromojiAnalysisTests1, kuromojiAnalysisTests26 };
java.util.Set<org.elasticsearch.index.analysis.KuromojiAnalysisTests> kuromojiAnalysisTestsSet38 = org.apache.lucene.util.LuceneTestCase.asSet(kuromojiAnalysisTestsArray37);
java.util.Set<org.elasticsearch.test.ESTestCase> eSTestCaseSet39 = org.apache.lucene.util.LuceneTestCase.asSet((org.elasticsearch.test.ESTestCase[]) kuromojiAnalysisTestsArray37);
java.io.PrintStream printStream40 = null;
// The following exception was thrown during execution in test generation
try {
org.apache.lucene.util.LuceneTestCase.dumpArray("<unknown>", (java.lang.Object[]) kuromojiAnalysisTestsArray37, printStream40);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain17);
org.junit.Assert.assertNotNull(testRule27);
org.junit.Assert.assertEquals("'" + str36 + "' != '" + "<unknown>" + "'", str36, "<unknown>");
org.junit.Assert.assertNotNull(kuromojiAnalysisTestsArray37);
org.junit.Assert.assertNotNull(kuromojiAnalysisTestsSet38);
org.junit.Assert.assertNotNull(eSTestCaseSet39);
}
@Test
public void test17680() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17680");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) (byte) 1);
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader12, fields13, fields14, false);
kuromojiAnalysisTests0.assertPathHasBeenCleared("random");
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.assertPathHasBeenCleared("europarl.lines.txt.gz");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests22.tearDown();
org.apache.lucene.index.IndexReader indexReader25 = null;
org.apache.lucene.index.Fields fields26 = null;
org.apache.lucene.index.Fields fields27 = null;
kuromojiAnalysisTests22.assertFieldsEquals("enwiki.random.lines.txt", indexReader25, fields26, fields27, true);
kuromojiAnalysisTests22.setUp();
kuromojiAnalysisTests22.tearDown();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests22);
org.junit.Assert.assertNotSame((java.lang.Object) "europarl.lines.txt.gz", (java.lang.Object) kuromojiAnalysisTests22);
kuromojiAnalysisTests22.ensureCleanedUp();
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment35 = kuromojiAnalysisTests22.newNodeEnvironment();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17681() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17681");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests2 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule3 = kuromojiAnalysisTests2.ruleChain;
kuromojiAnalysisTests2.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests2);
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.Terms terms8 = null;
org.apache.lucene.index.Terms terms9 = null;
kuromojiAnalysisTests2.assertTermsEquals("random", indexReader7, terms8, terms9, false);
org.junit.rules.RuleChain ruleChain12 = kuromojiAnalysisTests2.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests2.assertTermsEquals("europarl.lines.txt.gz", indexReader14, terms15, terms16, false);
org.junit.rules.RuleChain ruleChain19 = kuromojiAnalysisTests2.failureAndSuccessEvents;
org.junit.Assert.assertNotNull("<unknown>", (java.lang.Object) kuromojiAnalysisTests2);
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.env.NodeEnvironment nodeEnvironment21 = kuromojiAnalysisTests2.newNodeEnvironment();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule3);
org.junit.Assert.assertNotNull(ruleChain12);
org.junit.Assert.assertNotNull(ruleChain19);
}
@Test
public void test17682() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17682");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum39 = null;
org.apache.lucene.index.PostingsEnum postingsEnum40 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader37, 0, postingsEnum39, postingsEnum40);
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.weekly", postingsEnum43, postingsEnum44, true);
org.junit.rules.TestRule testRule47 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(testRule47);
}
@Test
public void test17683() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17683");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
org.apache.lucene.index.IndexReader indexReader37 = null;
org.apache.lucene.index.Fields fields38 = null;
org.apache.lucene.index.Fields fields39 = null;
kuromojiAnalysisTests0.assertFieldsEquals("europarl.lines.txt.gz", indexReader37, fields38, fields39, false);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.setIndexWriterMaxDocs((int) '#');
org.apache.lucene.index.IndexReader indexReader46 = null;
org.apache.lucene.index.Fields fields47 = null;
org.apache.lucene.index.Fields fields48 = null;
kuromojiAnalysisTests0.assertFieldsEquals("<unknown>", indexReader46, fields47, fields48, true);
// The following exception was thrown during execution in test generation
try {
org.elasticsearch.index.analysis.AnalysisService analysisService51 = kuromojiAnalysisTests0.createAnalysisService();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17684() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17684");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain3 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum7 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("random", postingsEnum6, postingsEnum7, true);
org.apache.lucene.index.IndexReader indexReader11 = null;
org.apache.lucene.index.TermsEnum termsEnum12 = null;
org.apache.lucene.index.TermsEnum termsEnum13 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermsEnumEquals("", indexReader11, termsEnum12, termsEnum13, true);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain3);
}
@Test
public void test17685() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17685");
org.junit.Assert.assertNotEquals("<unknown>", (long) '#', (long) 0);
}
@Test
public void test17686() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17686");
org.junit.Assert.assertNotEquals((long) (byte) 1, (long) (short) 100);
}
@Test
public void test17687() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17687");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("enwiki.random.lines.txt", postingsEnum37, postingsEnum38, true);
org.apache.lucene.index.IndexReader indexReader42 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum45 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("hi!", indexReader42, 0, postingsEnum44, postingsEnum45);
kuromojiAnalysisTests0.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader49 = null;
org.apache.lucene.index.Terms terms50 = null;
org.apache.lucene.index.Terms terms51 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.nightly", indexReader49, terms50, terms51, false);
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.badapples");
org.apache.lucene.index.IndexReader indexReader58 = null;
org.apache.lucene.index.Terms terms59 = null;
org.apache.lucene.index.Terms terms60 = null;
kuromojiAnalysisTests0.assertTermsEquals("hi!", indexReader58, terms59, terms60, false);
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
}
@Test
public void test17688() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17688");
org.junit.Assert.assertEquals("tests.badapples", (double) '#', (double) '4', (double) ' ');
}
@Test
public void test17689() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17689");
short[] shortArray4 = new short[] {};
short[] shortArray5 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray4, shortArray5);
short[] shortArray9 = new short[] {};
short[] shortArray10 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray9, shortArray10);
short[] shortArray13 = new short[] {};
short[] shortArray14 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray13, shortArray14);
org.junit.Assert.assertArrayEquals(shortArray9, shortArray13);
short[] shortArray18 = new short[] {};
short[] shortArray19 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray18, shortArray19);
short[] shortArray22 = new short[] {};
short[] shortArray23 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray22, shortArray23);
org.junit.Assert.assertArrayEquals(shortArray18, shortArray22);
org.junit.Assert.assertArrayEquals("tests.awaitsfix", shortArray9, shortArray22);
org.junit.Assert.assertArrayEquals("tests.monster", shortArray4, shortArray22);
short[] shortArray29 = new short[] {};
short[] shortArray30 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray29, shortArray30);
short[] shortArray33 = new short[] {};
short[] shortArray34 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray33, shortArray34);
org.junit.Assert.assertArrayEquals(shortArray29, shortArray33);
org.junit.Assert.assertArrayEquals("", shortArray4, shortArray29);
short[] shortArray40 = new short[] {};
short[] shortArray41 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray40, shortArray41);
short[] shortArray44 = new short[] {};
short[] shortArray45 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray44, shortArray45);
org.junit.Assert.assertArrayEquals(shortArray40, shortArray44);
short[] shortArray50 = new short[] {};
short[] shortArray51 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray50, shortArray51);
short[] shortArray54 = new short[] {};
short[] shortArray55 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray54, shortArray55);
org.junit.Assert.assertArrayEquals(shortArray50, shortArray54);
short[] shortArray59 = new short[] {};
short[] shortArray60 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray59, shortArray60);
short[] shortArray63 = new short[] {};
short[] shortArray64 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray63, shortArray64);
org.junit.Assert.assertArrayEquals(shortArray59, shortArray63);
org.junit.Assert.assertArrayEquals("<unknown>", shortArray50, shortArray63);
org.junit.Assert.assertArrayEquals("", shortArray44, shortArray50);
short[] shortArray71 = new short[] {};
short[] shortArray72 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray71, shortArray72);
short[] shortArray75 = new short[] {};
short[] shortArray76 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray75, shortArray76);
org.junit.Assert.assertArrayEquals("", shortArray72, shortArray75);
org.junit.Assert.assertArrayEquals(shortArray50, shortArray75);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", shortArray29, shortArray50);
org.junit.Assert.assertNotNull(shortArray4);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray4), "[]");
org.junit.Assert.assertNotNull(shortArray5);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray5), "[]");
org.junit.Assert.assertNotNull(shortArray9);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray9), "[]");
org.junit.Assert.assertNotNull(shortArray10);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray10), "[]");
org.junit.Assert.assertNotNull(shortArray13);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray13), "[]");
org.junit.Assert.assertNotNull(shortArray14);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray14), "[]");
org.junit.Assert.assertNotNull(shortArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray18), "[]");
org.junit.Assert.assertNotNull(shortArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray19), "[]");
org.junit.Assert.assertNotNull(shortArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray22), "[]");
org.junit.Assert.assertNotNull(shortArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray23), "[]");
org.junit.Assert.assertNotNull(shortArray29);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray29), "[]");
org.junit.Assert.assertNotNull(shortArray30);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray30), "[]");
org.junit.Assert.assertNotNull(shortArray33);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray33), "[]");
org.junit.Assert.assertNotNull(shortArray34);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray34), "[]");
org.junit.Assert.assertNotNull(shortArray40);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray40), "[]");
org.junit.Assert.assertNotNull(shortArray41);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray41), "[]");
org.junit.Assert.assertNotNull(shortArray44);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray44), "[]");
org.junit.Assert.assertNotNull(shortArray45);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray45), "[]");
org.junit.Assert.assertNotNull(shortArray50);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray50), "[]");
org.junit.Assert.assertNotNull(shortArray51);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray51), "[]");
org.junit.Assert.assertNotNull(shortArray54);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray54), "[]");
org.junit.Assert.assertNotNull(shortArray55);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray55), "[]");
org.junit.Assert.assertNotNull(shortArray59);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray59), "[]");
org.junit.Assert.assertNotNull(shortArray60);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray60), "[]");
org.junit.Assert.assertNotNull(shortArray63);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray63), "[]");
org.junit.Assert.assertNotNull(shortArray64);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray64), "[]");
org.junit.Assert.assertNotNull(shortArray71);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray71), "[]");
org.junit.Assert.assertNotNull(shortArray72);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray72), "[]");
org.junit.Assert.assertNotNull(shortArray75);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray75), "[]");
org.junit.Assert.assertNotNull(shortArray76);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray76), "[]");
}
@Test
public void test17690() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17690");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
java.lang.String str42 = kuromojiAnalysisTests0.getTestName();
java.lang.String str43 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.nightly", indexReader45, terms46, terms47, true);
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests0);
org.apache.lucene.index.TermsEnum termsEnum53 = null;
org.apache.lucene.index.TermsEnum termsEnum54 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermStatsEquals("europarl.lines.txt.gz", termsEnum53, termsEnum54);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "<unknown>" + "'", str42, "<unknown>");
org.junit.Assert.assertEquals("'" + str43 + "' != '" + "<unknown>" + "'", str43, "<unknown>");
}
@Test
public void test17691() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17691");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.junit.rules.RuleChain ruleChain15 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("tests.maxfailures", postingsEnum18, postingsEnum19, false);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests22.tearDown();
org.apache.lucene.index.IndexReader indexReader25 = null;
org.apache.lucene.index.Terms terms26 = null;
org.apache.lucene.index.Terms terms27 = null;
kuromojiAnalysisTests22.assertTermsEquals("tests.failfast", indexReader25, terms26, terms27, false);
org.apache.lucene.index.IndexReader indexReader31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum33 = null;
org.apache.lucene.index.PostingsEnum postingsEnum34 = null;
kuromojiAnalysisTests22.assertDocsSkippingEquals("tests.nightly", indexReader31, (int) (byte) -1, postingsEnum33, postingsEnum34, false);
org.apache.lucene.index.IndexReader indexReader38 = null;
org.apache.lucene.index.Terms terms39 = null;
org.apache.lucene.index.Terms terms40 = null;
kuromojiAnalysisTests22.assertTermsEquals("", indexReader38, terms39, terms40, true);
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
kuromojiAnalysisTests22.assertDocsSkippingEquals("<unknown>", indexReader44, (int) (byte) 100, postingsEnum46, postingsEnum47, false);
kuromojiAnalysisTests22.assertPathHasBeenCleared("random");
org.junit.rules.TestRule testRule52 = kuromojiAnalysisTests22.ruleChain;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests54 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests54.tearDown();
org.apache.lucene.index.IndexReader indexReader57 = null;
org.apache.lucene.index.Terms terms58 = null;
org.apache.lucene.index.Terms terms59 = null;
kuromojiAnalysisTests54.assertTermsEquals("tests.failfast", indexReader57, terms58, terms59, false);
org.apache.lucene.index.IndexReader indexReader63 = null;
org.apache.lucene.index.PostingsEnum postingsEnum65 = null;
org.apache.lucene.index.PostingsEnum postingsEnum66 = null;
kuromojiAnalysisTests54.assertDocsSkippingEquals("tests.nightly", indexReader63, (int) (byte) -1, postingsEnum65, postingsEnum66, false);
org.junit.rules.RuleChain ruleChain69 = kuromojiAnalysisTests54.failureAndSuccessEvents;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures70 = null;
org.apache.lucene.util.TestRuleIgnoreAfterMaxFailures testRuleIgnoreAfterMaxFailures71 = org.apache.lucene.util.LuceneTestCase.replaceMaxFailureRule(testRuleIgnoreAfterMaxFailures70);
org.junit.rules.RuleChain ruleChain72 = ruleChain69.around((org.junit.rules.TestRule) testRuleIgnoreAfterMaxFailures71);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling74 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray75 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling74 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet76 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray75);
java.util.List<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingList77 = org.elasticsearch.test.ESTestCase.randomSubsetOf(0, throttlingArray75);
org.apache.lucene.store.MockDirectoryWrapper.Throttling throttling78 = org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES;
org.apache.lucene.store.MockDirectoryWrapper.Throttling[] throttlingArray79 = new org.apache.lucene.store.MockDirectoryWrapper.Throttling[] { throttling78 };
java.util.Set<org.apache.lucene.store.MockDirectoryWrapper.Throttling> throttlingSet80 = org.apache.lucene.util.LuceneTestCase.asSet(throttlingArray79);
org.junit.Assert.assertEquals((java.lang.Object[]) throttlingArray75, (java.lang.Object[]) throttlingArray79);
org.junit.Assert.assertNotSame((java.lang.Object) ruleChain69, (java.lang.Object) throttlingArray79);
org.junit.Assert.assertNotNull("tests.failfast", (java.lang.Object) ruleChain69);
kuromojiAnalysisTests22.failureAndSuccessEvents = ruleChain69;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain69;
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.weekly");
kuromojiAnalysisTests0.ensureCleanedUp();
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.testKatakanaStemFilter();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(ruleChain15);
org.junit.Assert.assertNotNull(testRule52);
org.junit.Assert.assertNotNull(ruleChain69);
org.junit.Assert.assertNull(testRuleIgnoreAfterMaxFailures71);
org.junit.Assert.assertNotNull(ruleChain72);
org.junit.Assert.assertTrue("'" + throttling74 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling74.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray75);
org.junit.Assert.assertNotNull(throttlingSet76);
org.junit.Assert.assertNotNull(throttlingList77);
org.junit.Assert.assertTrue("'" + throttling78 + "' != '" + org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES + "'", throttling78.equals(org.apache.lucene.store.MockDirectoryWrapper.Throttling.SOMETIMES));
org.junit.Assert.assertNotNull(throttlingArray79);
org.junit.Assert.assertNotNull(throttlingSet80);
}
@Test
public void test17692() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17692");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
kuromojiAnalysisTests1.resetCheckIndexStatus();
kuromojiAnalysisTests1.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader12 = null;
org.apache.lucene.index.Fields fields13 = null;
org.apache.lucene.index.Fields fields14 = null;
kuromojiAnalysisTests1.assertFieldsEquals("tests.monster", indexReader12, fields13, fields14, false);
org.junit.rules.RuleChain ruleChain17 = kuromojiAnalysisTests1.failureAndSuccessEvents;
org.junit.Assert.assertNotNull("hi!", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.Terms terms21 = null;
org.apache.lucene.index.Terms terms22 = null;
kuromojiAnalysisTests1.assertTermsEquals("", indexReader20, terms21, terms22, true);
org.junit.rules.RuleChain ruleChain25 = kuromojiAnalysisTests1.failureAndSuccessEvents;
kuromojiAnalysisTests1.ensureCheckIndexPassed();
org.junit.Assert.assertNotNull(ruleChain17);
org.junit.Assert.assertNotNull(ruleChain25);
}
@Test
public void test17693() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17693");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain3 = kuromojiAnalysisTests0.failureAndSuccessEvents;
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("europarl.lines.txt.gz", indexReader6, (-1), postingsEnum8, postingsEnum9, true);
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
// The following exception was thrown during execution in test generation
try {
java.nio.file.Path path15 = kuromojiAnalysisTests0.getDataPath("");
org.junit.Assert.fail("Expected exception of type java.lang.RuntimeException; message: resource not found: ");
} catch (java.lang.RuntimeException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain3);
}
@Test
public void test17694() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17694");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.setUp();
org.junit.rules.TestRule testRule8 = kuromojiAnalysisTests0.ruleChain;
org.apache.lucene.index.IndexReader indexReader10 = null;
org.apache.lucene.index.Fields fields11 = null;
org.apache.lucene.index.Fields fields12 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader10, fields11, fields12, false);
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(testRule8);
}
@Test
public void test17695() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17695");
// The following exception was thrown during execution in test generation
try {
java.lang.String[] strArray3 = org.elasticsearch.test.ESTestCase.generateRandomStringArray(10, 100, true);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17696() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17696");
short[] shortArray2 = new short[] {};
short[] shortArray3 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray2, shortArray3);
short[] shortArray6 = new short[] {};
short[] shortArray7 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray6, shortArray7);
org.junit.Assert.assertArrayEquals(shortArray2, shortArray6);
short[] shortArray11 = new short[] {};
short[] shortArray12 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray11, shortArray12);
org.junit.Assert.assertArrayEquals("tests.maxfailures", shortArray6, shortArray12);
short[] shortArray18 = new short[] {};
short[] shortArray19 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray18, shortArray19);
short[] shortArray22 = new short[] {};
short[] shortArray23 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray22, shortArray23);
org.junit.Assert.assertArrayEquals(shortArray18, shortArray22);
short[] shortArray27 = new short[] {};
short[] shortArray28 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray27, shortArray28);
org.junit.Assert.assertArrayEquals("tests.badapples", shortArray18, shortArray28);
short[] shortArray32 = new short[] {};
short[] shortArray33 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray32, shortArray33);
short[] shortArray36 = new short[] {};
short[] shortArray37 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray36, shortArray37);
org.junit.Assert.assertArrayEquals(shortArray32, shortArray36);
org.junit.Assert.assertArrayEquals(shortArray28, shortArray32);
short[] shortArray44 = new short[] {};
short[] shortArray45 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray44, shortArray45);
short[] shortArray48 = new short[] {};
short[] shortArray49 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray48, shortArray49);
org.junit.Assert.assertArrayEquals(shortArray44, shortArray48);
short[] shortArray53 = new short[] {};
short[] shortArray54 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray53, shortArray54);
short[] shortArray57 = new short[] {};
short[] shortArray58 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray57, shortArray58);
org.junit.Assert.assertArrayEquals(shortArray53, shortArray57);
org.junit.Assert.assertArrayEquals("<unknown>", shortArray44, shortArray57);
short[] shortArray63 = new short[] {};
short[] shortArray64 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray63, shortArray64);
short[] shortArray67 = new short[] {};
short[] shortArray68 = new short[] {};
org.junit.Assert.assertArrayEquals("tests.monster", shortArray67, shortArray68);
org.junit.Assert.assertArrayEquals(shortArray63, shortArray67);
org.junit.Assert.assertArrayEquals("tests.nightly", shortArray57, shortArray67);
org.junit.Assert.assertArrayEquals("tests.awaitsfix", shortArray28, shortArray57);
org.junit.Assert.assertArrayEquals(shortArray6, shortArray28);
org.junit.Assert.assertNotNull(shortArray2);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray2), "[]");
org.junit.Assert.assertNotNull(shortArray3);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray3), "[]");
org.junit.Assert.assertNotNull(shortArray6);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray6), "[]");
org.junit.Assert.assertNotNull(shortArray7);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray7), "[]");
org.junit.Assert.assertNotNull(shortArray11);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray11), "[]");
org.junit.Assert.assertNotNull(shortArray12);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray12), "[]");
org.junit.Assert.assertNotNull(shortArray18);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray18), "[]");
org.junit.Assert.assertNotNull(shortArray19);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray19), "[]");
org.junit.Assert.assertNotNull(shortArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray22), "[]");
org.junit.Assert.assertNotNull(shortArray23);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray23), "[]");
org.junit.Assert.assertNotNull(shortArray27);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray27), "[]");
org.junit.Assert.assertNotNull(shortArray28);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray28), "[]");
org.junit.Assert.assertNotNull(shortArray32);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray32), "[]");
org.junit.Assert.assertNotNull(shortArray33);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray33), "[]");
org.junit.Assert.assertNotNull(shortArray36);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray36), "[]");
org.junit.Assert.assertNotNull(shortArray37);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray37), "[]");
org.junit.Assert.assertNotNull(shortArray44);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray44), "[]");
org.junit.Assert.assertNotNull(shortArray45);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray45), "[]");
org.junit.Assert.assertNotNull(shortArray48);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray48), "[]");
org.junit.Assert.assertNotNull(shortArray49);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray49), "[]");
org.junit.Assert.assertNotNull(shortArray53);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray53), "[]");
org.junit.Assert.assertNotNull(shortArray54);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray54), "[]");
org.junit.Assert.assertNotNull(shortArray57);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray57), "[]");
org.junit.Assert.assertNotNull(shortArray58);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray58), "[]");
org.junit.Assert.assertNotNull(shortArray63);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray63), "[]");
org.junit.Assert.assertNotNull(shortArray64);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray64), "[]");
org.junit.Assert.assertNotNull(shortArray67);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray67), "[]");
org.junit.Assert.assertNotNull(shortArray68);
org.junit.Assert.assertEquals(java.util.Arrays.toString(shortArray68), "[]");
}
@Test
public void test17697() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17697");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.Terms terms7 = null;
org.apache.lucene.index.Terms terms8 = null;
kuromojiAnalysisTests1.assertTermsEquals("random", indexReader6, terms7, terms8, false);
kuromojiAnalysisTests1.ensureCleanedUp();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.monster", indexReader13, 1, postingsEnum15, postingsEnum16);
org.junit.Assert.assertNotNull(testRule2);
}
@Test
public void test17698() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17698");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
org.apache.lucene.index.IndexReader indexReader7 = null;
org.apache.lucene.index.Terms terms8 = null;
org.apache.lucene.index.Terms terms9 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.awaitsfix", indexReader7, terms8, terms9, true);
kuromojiAnalysisTests0.setUp();
kuromojiAnalysisTests0.assertPathHasBeenCleared("enwiki.random.lines.txt");
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.IndexReader indexReader17 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertStoredFieldsEquals("", indexReader16, indexReader17);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
}
@Test
public void test17699() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17699");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
org.apache.lucene.index.IndexReader indexReader36 = null;
org.apache.lucene.index.Terms terms37 = null;
org.apache.lucene.index.Terms terms38 = null;
kuromojiAnalysisTests0.assertTermsEquals("random", indexReader36, terms37, terms38, false);
kuromojiAnalysisTests0.overrideTestDefaultQueryCache();
org.junit.rules.RuleChain ruleChain42 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.apache.lucene.index.IndexReader indexReader44 = null;
org.apache.lucene.index.PostingsEnum postingsEnum46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum47 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.weekly", indexReader44, (int) (short) 100, postingsEnum46, postingsEnum47);
org.junit.rules.TestRule testRule49 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("tests.maxfailures");
org.junit.rules.TestRule testRule52 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.assertPathHasBeenCleared("random");
org.junit.Assert.assertNotNull((java.lang.Object) kuromojiAnalysisTests0);
java.util.concurrent.ExecutorService[] executorServiceArray57 = new java.util.concurrent.ExecutorService[] {};
boolean boolean58 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray57);
java.io.Serializable[] serializableArray60 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet61 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray60);
java.io.Serializable[] serializableArray63 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet64 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray63);
java.io.Serializable[] serializableArray66 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet67 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray66);
java.io.Serializable[] serializableArray68 = new java.io.Serializable[] {};
java.util.Set<java.io.Serializable> serializableSet69 = org.apache.lucene.util.LuceneTestCase.asSet(serializableArray68);
org.junit.Assert.assertArrayEquals("", (java.lang.Object[]) serializableArray66, (java.lang.Object[]) serializableArray68);
org.junit.Assert.assertArrayEquals("tests.failfast", (java.lang.Object[]) serializableArray63, (java.lang.Object[]) serializableArray68);
org.junit.Assert.assertEquals("tests.nightly", (java.lang.Object[]) serializableArray60, (java.lang.Object[]) serializableArray68);
org.junit.Assert.assertArrayEquals((java.lang.Object[]) executorServiceArray57, (java.lang.Object[]) serializableArray60);
org.junit.Assert.assertNotNull("europarl.lines.txt.gz", (java.lang.Object) executorServiceArray57);
boolean boolean75 = org.elasticsearch.test.ESTestCase.terminate(executorServiceArray57);
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) executorServiceArray57);
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(ruleChain42);
org.junit.Assert.assertNotNull(testRule49);
org.junit.Assert.assertNotNull(testRule52);
org.junit.Assert.assertNotNull(executorServiceArray57);
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + true + "'", boolean58 == true);
org.junit.Assert.assertNotNull(serializableArray60);
org.junit.Assert.assertNotNull(serializableSet61);
org.junit.Assert.assertNotNull(serializableArray63);
org.junit.Assert.assertNotNull(serializableSet64);
org.junit.Assert.assertNotNull(serializableArray66);
org.junit.Assert.assertNotNull(serializableSet67);
org.junit.Assert.assertNotNull(serializableArray68);
org.junit.Assert.assertNotNull(serializableSet69);
org.junit.Assert.assertTrue("'" + boolean75 + "' != '" + true + "'", boolean75 == true);
}
@Test
public void test17700() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17700");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Terms terms4 = null;
org.apache.lucene.index.Terms terms5 = null;
kuromojiAnalysisTests0.assertTermsEquals("tests.failfast", indexReader3, terms4, terms5, false);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.nightly", indexReader9, (int) (byte) -1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader16, (int) (short) -1, postingsEnum18, postingsEnum19);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests22 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule23 = kuromojiAnalysisTests22.ruleChain;
kuromojiAnalysisTests22.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests22);
org.junit.rules.RuleChain ruleChain26 = kuromojiAnalysisTests22.failureAndSuccessEvents;
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain26;
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum31 = null;
org.apache.lucene.index.PostingsEnum postingsEnum32 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.badapples", indexReader29, 0, postingsEnum31, postingsEnum32, true);
kuromojiAnalysisTests0.resetCheckIndexStatus();
org.apache.lucene.index.PostingsEnum postingsEnum37 = null;
org.apache.lucene.index.PostingsEnum postingsEnum38 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("", postingsEnum37, postingsEnum38, false);
org.junit.rules.TestRule testRule41 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureCleanedUp();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader46 = null;
org.apache.lucene.index.PostingsEnum postingsEnum48 = null;
org.apache.lucene.index.PostingsEnum postingsEnum49 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.maxfailures", indexReader46, (int) (byte) 10, postingsEnum48, postingsEnum49);
org.junit.rules.TestRule testRule51 = org.apache.lucene.util.LuceneTestCase.classRules;
org.junit.rules.RuleChain ruleChain52 = org.junit.rules.RuleChain.outerRule(testRule51);
org.junit.rules.RuleChain ruleChain53 = org.junit.rules.RuleChain.outerRule(testRule51);
org.junit.rules.RuleChain ruleChain54 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain53);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain54;
java.lang.String str56 = kuromojiAnalysisTests0.getTestName();
org.junit.Assert.assertNotNull(testRule23);
org.junit.Assert.assertNotNull(ruleChain26);
org.junit.Assert.assertNotNull(testRule41);
org.junit.Assert.assertNotNull(testRule51);
org.junit.Assert.assertNotNull(ruleChain52);
org.junit.Assert.assertNotNull(ruleChain53);
org.junit.Assert.assertNotNull(ruleChain54);
org.junit.Assert.assertEquals("'" + str56 + "' != '" + "<unknown>" + "'", str56, "<unknown>");
}
@Test
public void test17701() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17701");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
kuromojiAnalysisTests0.setUp();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) "<unknown>");
org.junit.rules.RuleChain ruleChain18 = kuromojiAnalysisTests0.failureAndSuccessEvents;
org.junit.rules.RuleChain ruleChain19 = org.junit.rules.RuleChain.outerRule((org.junit.rules.TestRule) ruleChain18);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests20 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule21 = kuromojiAnalysisTests20.ruleChain;
kuromojiAnalysisTests20.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain23 = kuromojiAnalysisTests20.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests25 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule26 = kuromojiAnalysisTests25.ruleChain;
kuromojiAnalysisTests25.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests25);
org.apache.lucene.index.IndexReader indexReader30 = null;
org.apache.lucene.index.Terms terms31 = null;
org.apache.lucene.index.Terms terms32 = null;
kuromojiAnalysisTests25.assertTermsEquals("random", indexReader30, terms31, terms32, false);
org.junit.rules.RuleChain ruleChain35 = kuromojiAnalysisTests25.failureAndSuccessEvents;
org.junit.runners.model.Statement statement36 = null;
org.junit.runner.Description description37 = null;
org.junit.runners.model.Statement statement38 = ruleChain35.apply(statement36, description37);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests40 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule41 = kuromojiAnalysisTests40.ruleChain;
kuromojiAnalysisTests40.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests40);
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests40.assertTermsEquals("random", indexReader45, terms46, terms47, false);
org.junit.rules.RuleChain ruleChain50 = kuromojiAnalysisTests40.failureAndSuccessEvents;
org.junit.runners.model.Statement statement51 = null;
org.junit.runner.Description description52 = null;
org.junit.runners.model.Statement statement53 = ruleChain50.apply(statement51, description52);
org.junit.runner.Description description54 = null;
org.junit.runners.model.Statement statement55 = ruleChain35.apply(statement53, description54);
org.junit.rules.TestRule testRule56 = org.apache.lucene.util.LuceneTestCase.classRules;
org.junit.rules.RuleChain ruleChain57 = org.junit.rules.RuleChain.outerRule(testRule56);
org.junit.rules.RuleChain ruleChain58 = ruleChain35.around(testRule56);
org.junit.rules.RuleChain ruleChain59 = ruleChain23.around((org.junit.rules.TestRule) ruleChain35);
org.apache.lucene.util.LuceneTestCase.classRules = ruleChain23;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests62 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule63 = kuromojiAnalysisTests62.ruleChain;
kuromojiAnalysisTests62.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests62);
org.junit.rules.RuleChain ruleChain66 = kuromojiAnalysisTests62.failureAndSuccessEvents;
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests67 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests67.tearDown();
org.apache.lucene.index.IndexReader indexReader70 = null;
org.apache.lucene.index.Terms terms71 = null;
org.apache.lucene.index.Terms terms72 = null;
kuromojiAnalysisTests67.assertTermsEquals("tests.failfast", indexReader70, terms71, terms72, false);
org.apache.lucene.index.IndexReader indexReader76 = null;
org.apache.lucene.index.Terms terms77 = null;
org.apache.lucene.index.Terms terms78 = null;
kuromojiAnalysisTests67.assertTermsEquals("", indexReader76, terms77, terms78, false);
org.junit.rules.RuleChain ruleChain81 = kuromojiAnalysisTests67.failureAndSuccessEvents;
org.junit.runners.model.Statement statement82 = null;
org.junit.runner.Description description83 = null;
org.junit.runners.model.Statement statement84 = ruleChain81.apply(statement82, description83);
org.junit.runner.Description description85 = null;
org.junit.runners.model.Statement statement86 = ruleChain66.apply(statement84, description85);
org.junit.runner.Description description87 = null;
org.junit.runners.model.Statement statement88 = ruleChain23.apply(statement84, description87);
org.junit.runner.Description description89 = null;
org.junit.runners.model.Statement statement90 = ruleChain18.apply(statement88, description89);
org.junit.Assert.assertNotNull(ruleChain18);
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(testRule21);
org.junit.Assert.assertNotNull(ruleChain23);
org.junit.Assert.assertNotNull(testRule26);
org.junit.Assert.assertNotNull(ruleChain35);
org.junit.Assert.assertNotNull(statement38);
org.junit.Assert.assertNotNull(testRule41);
org.junit.Assert.assertNotNull(ruleChain50);
org.junit.Assert.assertNotNull(statement53);
org.junit.Assert.assertNotNull(statement55);
org.junit.Assert.assertNotNull(testRule56);
org.junit.Assert.assertNotNull(ruleChain57);
org.junit.Assert.assertNotNull(ruleChain58);
org.junit.Assert.assertNotNull(ruleChain59);
org.junit.Assert.assertNotNull(testRule63);
org.junit.Assert.assertNotNull(ruleChain66);
org.junit.Assert.assertNotNull(ruleChain81);
org.junit.Assert.assertNotNull(statement84);
org.junit.Assert.assertNotNull(statement86);
org.junit.Assert.assertNotNull(statement88);
org.junit.Assert.assertNotNull(statement90);
}
@Test
public void test17702() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17702");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests1.tearDown();
org.apache.lucene.index.IndexReader indexReader4 = null;
org.apache.lucene.index.Fields fields5 = null;
org.apache.lucene.index.Fields fields6 = null;
kuromojiAnalysisTests1.assertFieldsEquals("enwiki.random.lines.txt", indexReader4, fields5, fields6, true);
kuromojiAnalysisTests1.setUp();
org.junit.Assert.assertNotNull("tests.maxfailures", (java.lang.Object) kuromojiAnalysisTests1);
kuromojiAnalysisTests1.ensureCleanedUp();
org.junit.rules.TestRule testRule12 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
long[] longArray20 = new long[] { (byte) 0 };
long[] longArray22 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray20, longArray22);
long[] longArray25 = new long[] { (byte) 0 };
long[] longArray27 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray25, longArray27);
org.junit.Assert.assertArrayEquals("", longArray20, longArray27);
long[] longArray32 = new long[] { (byte) 0 };
long[] longArray34 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray32, longArray34);
long[] longArray37 = new long[] { (byte) 0 };
long[] longArray39 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray37, longArray39);
org.junit.Assert.assertArrayEquals("", longArray32, longArray39);
org.junit.Assert.assertArrayEquals("tests.failfast", longArray20, longArray39);
org.junit.Assert.assertNotEquals("tests.nightly", (java.lang.Object) "tests.monster", (java.lang.Object) longArray39);
long[] longArray46 = new long[] { (byte) 0 };
long[] longArray48 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray46, longArray48);
long[] longArray51 = new long[] { (byte) 0 };
long[] longArray53 = new long[] { (short) 0 };
org.junit.Assert.assertArrayEquals(longArray51, longArray53);
org.junit.Assert.assertArrayEquals("", longArray46, longArray53);
org.junit.Assert.assertArrayEquals("europarl.lines.txt.gz", longArray39, longArray53);
org.junit.Assert.assertNotSame((java.lang.Object) kuromojiAnalysisTests1, (java.lang.Object) longArray39);
org.apache.lucene.index.IndexReader indexReader59 = null;
org.apache.lucene.index.IndexReader indexReader60 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests1.assertDocValuesEquals("", indexReader59, indexReader60);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule12);
org.junit.Assert.assertNotNull(longArray20);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray20), "[0]");
org.junit.Assert.assertNotNull(longArray22);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray22), "[0]");
org.junit.Assert.assertNotNull(longArray25);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray25), "[0]");
org.junit.Assert.assertNotNull(longArray27);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray27), "[0]");
org.junit.Assert.assertNotNull(longArray32);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray32), "[0]");
org.junit.Assert.assertNotNull(longArray34);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray34), "[0]");
org.junit.Assert.assertNotNull(longArray37);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray37), "[0]");
org.junit.Assert.assertNotNull(longArray39);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray39), "[0]");
org.junit.Assert.assertNotNull(longArray46);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray46), "[0]");
org.junit.Assert.assertNotNull(longArray48);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray48), "[0]");
org.junit.Assert.assertNotNull(longArray51);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray51), "[0]");
org.junit.Assert.assertNotNull(longArray53);
org.junit.Assert.assertEquals(java.util.Arrays.toString(longArray53), "[0]");
}
@Test
public void test17703() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17703");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader3 = null;
org.apache.lucene.index.Fields fields4 = null;
org.apache.lucene.index.Fields fields5 = null;
kuromojiAnalysisTests0.assertFieldsEquals("enwiki.random.lines.txt", indexReader3, fields4, fields5, true);
org.apache.lucene.index.IndexReader indexReader9 = null;
org.apache.lucene.index.PostingsEnum postingsEnum11 = null;
org.apache.lucene.index.PostingsEnum postingsEnum12 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("", indexReader9, 1, postingsEnum11, postingsEnum12, false);
org.apache.lucene.index.IndexReader indexReader16 = null;
org.apache.lucene.index.PostingsEnum postingsEnum18 = null;
org.apache.lucene.index.PostingsEnum postingsEnum19 = null;
kuromojiAnalysisTests0.assertDocsSkippingEquals("tests.weekly", indexReader16, 1, postingsEnum18, postingsEnum19, false);
kuromojiAnalysisTests0.resetCheckIndexStatus();
kuromojiAnalysisTests0.ensureAllSearchContextsReleased();
java.lang.String str24 = kuromojiAnalysisTests0.getTestName();
org.apache.lucene.index.IndexReader indexReader26 = null;
org.apache.lucene.index.Fields fields27 = null;
org.apache.lucene.index.Fields fields28 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.failfast", indexReader26, fields27, fields28, false);
org.junit.Assert.assertEquals("'" + str24 + "' != '" + "<unknown>" + "'", str24, "<unknown>");
}
@Test
public void test17704() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17704");
// The following exception was thrown during execution in test generation
try {
java.lang.String str2 = org.elasticsearch.test.ESTestCase.randomUnicodeOfCodepointLengthBetween(2, (int) (short) 10);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalStateException; message: No context information for thread: Thread[id=1, name=main, state=RUNNABLE, group=main]. Is this thread running under a class com.carrotsearch.randomizedtesting.RandomizedRunner runner context? Add @RunWith(class com.carrotsearch.randomizedtesting.RandomizedRunner.class) to your test class. Make sure your code accesses random contexts within @BeforeClass and @AfterClass boundary (for example, static test class initializers are not permitted to access random contexts).");
} catch (java.lang.IllegalStateException e) {
// Expected exception.
}
}
@Test
public void test17705() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17705");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.junit.Assert.assertNotEquals((java.lang.Object) kuromojiAnalysisTests0, (java.lang.Object) (-1));
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.junit.rules.RuleChain ruleChain7 = org.junit.rules.RuleChain.emptyRuleChain();
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests9 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule10 = kuromojiAnalysisTests9.ruleChain;
kuromojiAnalysisTests9.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests9);
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests9.assertTermsEquals("random", indexReader14, terms15, terms16, false);
org.junit.rules.RuleChain ruleChain19 = kuromojiAnalysisTests9.failureAndSuccessEvents;
org.junit.runners.model.Statement statement20 = null;
org.junit.runner.Description description21 = null;
org.junit.runners.model.Statement statement22 = ruleChain19.apply(statement20, description21);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests24 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule25 = kuromojiAnalysisTests24.ruleChain;
kuromojiAnalysisTests24.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests24);
org.apache.lucene.index.IndexReader indexReader29 = null;
org.apache.lucene.index.Terms terms30 = null;
org.apache.lucene.index.Terms terms31 = null;
kuromojiAnalysisTests24.assertTermsEquals("random", indexReader29, terms30, terms31, false);
org.junit.rules.RuleChain ruleChain34 = kuromojiAnalysisTests24.failureAndSuccessEvents;
org.junit.runners.model.Statement statement35 = null;
org.junit.runner.Description description36 = null;
org.junit.runners.model.Statement statement37 = ruleChain34.apply(statement35, description36);
org.junit.runner.Description description38 = null;
org.junit.runners.model.Statement statement39 = ruleChain19.apply(statement37, description38);
org.junit.runner.Description description40 = null;
org.junit.runners.model.Statement statement41 = ruleChain7.apply(statement37, description40);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests42 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests42.tearDown();
org.apache.lucene.index.IndexReader indexReader45 = null;
org.apache.lucene.index.Terms terms46 = null;
org.apache.lucene.index.Terms terms47 = null;
kuromojiAnalysisTests42.assertTermsEquals("tests.failfast", indexReader45, terms46, terms47, false);
org.apache.lucene.index.IndexReader indexReader51 = null;
org.apache.lucene.index.PostingsEnum postingsEnum53 = null;
org.apache.lucene.index.PostingsEnum postingsEnum54 = null;
kuromojiAnalysisTests42.assertDocsSkippingEquals("tests.nightly", indexReader51, (int) (byte) -1, postingsEnum53, postingsEnum54, false);
org.apache.lucene.index.IndexReader indexReader58 = null;
org.apache.lucene.index.PostingsEnum postingsEnum60 = null;
org.apache.lucene.index.PostingsEnum postingsEnum61 = null;
kuromojiAnalysisTests42.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader58, (int) (short) -1, postingsEnum60, postingsEnum61);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests64 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule65 = kuromojiAnalysisTests64.ruleChain;
kuromojiAnalysisTests64.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests64);
org.junit.rules.RuleChain ruleChain68 = kuromojiAnalysisTests64.failureAndSuccessEvents;
kuromojiAnalysisTests42.failureAndSuccessEvents = ruleChain68;
org.apache.lucene.index.IndexReader indexReader71 = null;
org.apache.lucene.index.PostingsEnum postingsEnum73 = null;
org.apache.lucene.index.PostingsEnum postingsEnum74 = null;
kuromojiAnalysisTests42.assertDocsSkippingEquals("tests.badapples", indexReader71, 0, postingsEnum73, postingsEnum74, true);
kuromojiAnalysisTests42.resetCheckIndexStatus();
org.junit.Assert.assertNotEquals((java.lang.Object) ruleChain7, (java.lang.Object) kuromojiAnalysisTests42);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests79 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule80 = kuromojiAnalysisTests79.ruleChain;
org.junit.rules.RuleChain ruleChain81 = org.junit.rules.RuleChain.outerRule(testRule80);
org.junit.rules.RuleChain ruleChain82 = ruleChain7.around(testRule80);
kuromojiAnalysisTests0.failureAndSuccessEvents = ruleChain7;
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.IndexReader indexReader86 = null;
org.apache.lucene.index.Fields fields87 = null;
org.apache.lucene.index.Fields fields88 = null;
kuromojiAnalysisTests0.assertFieldsEquals("tests.maxfailures", indexReader86, fields87, fields88, false);
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertNotNull(ruleChain7);
org.junit.Assert.assertNotNull(testRule10);
org.junit.Assert.assertNotNull(ruleChain19);
org.junit.Assert.assertNotNull(statement22);
org.junit.Assert.assertNotNull(testRule25);
org.junit.Assert.assertNotNull(ruleChain34);
org.junit.Assert.assertNotNull(statement37);
org.junit.Assert.assertNotNull(statement39);
org.junit.Assert.assertNotNull(statement41);
org.junit.Assert.assertNotNull(testRule65);
org.junit.Assert.assertNotNull(ruleChain68);
org.junit.Assert.assertNotNull(testRule80);
org.junit.Assert.assertNotNull(ruleChain81);
org.junit.Assert.assertNotNull(ruleChain82);
}
@Test
public void test17706() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17706");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests1 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule2 = kuromojiAnalysisTests1.ruleChain;
kuromojiAnalysisTests1.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests1);
org.apache.lucene.index.IndexReader indexReader6 = null;
org.apache.lucene.index.PostingsEnum postingsEnum8 = null;
org.apache.lucene.index.PostingsEnum postingsEnum9 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.weekly", indexReader6, (int) (short) 1, postingsEnum8, postingsEnum9);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests11 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
kuromojiAnalysisTests11.tearDown();
org.apache.lucene.index.IndexReader indexReader14 = null;
org.apache.lucene.index.Terms terms15 = null;
org.apache.lucene.index.Terms terms16 = null;
kuromojiAnalysisTests11.assertTermsEquals("tests.failfast", indexReader14, terms15, terms16, false);
org.apache.lucene.index.IndexReader indexReader20 = null;
org.apache.lucene.index.PostingsEnum postingsEnum22 = null;
org.apache.lucene.index.PostingsEnum postingsEnum23 = null;
kuromojiAnalysisTests11.assertDocsSkippingEquals("tests.nightly", indexReader20, (int) (byte) -1, postingsEnum22, postingsEnum23, false);
org.apache.lucene.index.IndexReader indexReader27 = null;
org.apache.lucene.index.PostingsEnum postingsEnum29 = null;
org.apache.lucene.index.PostingsEnum postingsEnum30 = null;
kuromojiAnalysisTests11.assertPositionsSkippingEquals("enwiki.random.lines.txt", indexReader27, (int) (short) -1, postingsEnum29, postingsEnum30);
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests33 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule34 = kuromojiAnalysisTests33.ruleChain;
kuromojiAnalysisTests33.restoreIndexWriterMaxDocs();
org.junit.Assert.assertNotNull("enwiki.random.lines.txt", (java.lang.Object) kuromojiAnalysisTests33);
org.junit.rules.RuleChain ruleChain37 = kuromojiAnalysisTests33.failureAndSuccessEvents;
kuromojiAnalysisTests11.failureAndSuccessEvents = ruleChain37;
kuromojiAnalysisTests1.failureAndSuccessEvents = ruleChain37;
org.apache.lucene.index.IndexReader indexReader41 = null;
org.apache.lucene.index.PostingsEnum postingsEnum43 = null;
org.apache.lucene.index.PostingsEnum postingsEnum44 = null;
kuromojiAnalysisTests1.assertPositionsSkippingEquals("tests.monster", indexReader41, (int) (byte) 1, postingsEnum43, postingsEnum44);
kuromojiAnalysisTests1.overrideTestDefaultQueryCache();
kuromojiAnalysisTests1.assertPathHasBeenCleared("europarl.lines.txt.gz");
org.junit.Assert.assertNotNull(testRule2);
org.junit.Assert.assertNotNull(testRule34);
org.junit.Assert.assertNotNull(ruleChain37);
}
@Test
public void test17707() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17707");
java.lang.String[] strArray4 = new java.lang.String[] { "tests.nightly", "tests.badapples", "tests.weekly" };
java.lang.String[][] strArray5 = new java.lang.String[][] { strArray4 };
java.util.Set<java.lang.String[]> strArraySet6 = org.apache.lucene.util.LuceneTestCase.asSet(strArray5);
org.junit.Assert.assertNotNull("", (java.lang.Object) strArray5);
org.junit.Assert.assertNotNull(strArray4);
org.junit.Assert.assertNotNull(strArray5);
org.junit.Assert.assertNotNull(strArraySet6);
}
@Test
public void test17708() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest35.test17708");
org.elasticsearch.index.analysis.KuromojiAnalysisTests kuromojiAnalysisTests0 = new org.elasticsearch.index.analysis.KuromojiAnalysisTests();
org.junit.rules.TestRule testRule1 = kuromojiAnalysisTests0.ruleChain;
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
kuromojiAnalysisTests0.tearDown();
org.apache.lucene.index.PostingsEnum postingsEnum5 = null;
org.apache.lucene.index.PostingsEnum postingsEnum6 = null;
kuromojiAnalysisTests0.assertDocsEnumEquals("<unknown>", postingsEnum5, postingsEnum6, true);
java.lang.String str9 = kuromojiAnalysisTests0.getTestName();
kuromojiAnalysisTests0.ensureCheckIndexPassed();
kuromojiAnalysisTests0.restoreIndexWriterMaxDocs();
org.apache.lucene.index.IndexReader indexReader13 = null;
org.apache.lucene.index.PostingsEnum postingsEnum15 = null;
org.apache.lucene.index.PostingsEnum postingsEnum16 = null;
kuromojiAnalysisTests0.assertPositionsSkippingEquals("tests.failfast", indexReader13, (int) (byte) 1, postingsEnum15, postingsEnum16);
org.apache.lucene.index.TermsEnum termsEnum19 = null;
org.apache.lucene.index.TermsEnum termsEnum20 = null;
// The following exception was thrown during execution in test generation
try {
kuromojiAnalysisTests0.assertTermStatsEquals("tests.slow", termsEnum19, termsEnum20);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(testRule1);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "<unknown>" + "'", str9, "<unknown>");
}
}
| 71.517671 | 578 | 0.730595 |
d249bd4225de0f55c441e2806fa858b0f2808e0d | 7,730 | /**
* personium.io
* Copyright 2014 FUJITSU LIMITED
*
* 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.fujitsu.dc.test.jersey.box.acl.jaxb;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
* <p>
* Java class for anonymous complex type.
* <p>
* The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType>
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <choice minOccurs="0">
* <element name="read" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="write" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="alter-schema" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="read-properties" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="write-properties" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="read-acl" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="write-acl" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="bind" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="unbind" type="{http://www.w3.org/2001/XMLSchema}string"/>
* <element name="exec" type="{http://www.w3.org/2001/XMLSchema}string"/>
* </choice>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"read",
"write",
"alterSchema",
"readProperties",
"writeProperties",
"readAcl",
"writeAcl",
"bind",
"unbind",
"exec",
"all"
})
@XmlRootElement(name = "privilege")
public class Privilege {
String read;
String write;
@XmlElement(name = "alter-schema")
String alterSchema;
@XmlElement(name = "read-properties")
String readProperties;
@XmlElement(name = "write-properties")
String writeProperties;
@XmlElement(name = "read-acl")
String readAcl;
@XmlElement(name = "write-acl")
String writeAcl;
String bind;
String unbind;
String exec;
String all;
/**
* Gets the value of the read property.
* @return
* possible object is {@link String }
*/
public String getRead() {
return read;
}
/**
* Sets the value of the read property.
* @param value
* allowed object is {@link String }
*/
public void setRead(String value) {
this.read = value;
}
/**
* Gets the value of the write property.
* @return
* possible object is {@link String }
*/
public String getWrite() {
return write;
}
/**
* Sets the value of the write property.
* @param value
* allowed object is {@link String }
*/
public void setWrite(String value) {
this.write = value;
}
/**
* Gets the value of the alterSchema property.
* @return
* possible object is {@link String }
*/
public String getAlterSchema() {
return alterSchema;
}
/**
* Sets the value of the alterSchema property.
* @param value
* allowed object is {@link String }
*/
public void setAlterSchema(String value) {
this.alterSchema = value;
}
/**
* Gets the value of the readProperties property.
* @return
* possible object is {@link String }
*/
public String getReadProperties() {
return readProperties;
}
/**
* Sets the value of the readProperties property.
* @param value
* allowed object is {@link String }
*/
public void setReadProperties(String value) {
this.readProperties = value;
}
/**
* Gets the value of the writeProperties property.
* @return
* possible object is {@link String }
*/
public String getWriteProperties() {
return writeProperties;
}
/**
* Sets the value of the writeProperties property.
* @param value
* allowed object is {@link String }
*/
public void setWriteProperties(String value) {
this.writeProperties = value;
}
/**
* Gets the value of the readAcl property.
* @return
* possible object is {@link String }
*/
public String getReadAcl() {
return readAcl;
}
/**
* Sets the value of the readAcl property.
* @param value
* allowed object is {@link String }
*/
public void setReadAcl(String value) {
this.readAcl = value;
}
/**
* Gets the value of the writeAcl property.
* @return
* possible object is {@link String }
*/
public String getWriteAcl() {
return writeAcl;
}
/**
* Sets the value of the writeAcl property.
* @param value
* allowed object is {@link String }
*/
public void setWriteAcl(String value) {
this.writeAcl = value;
}
/**
* Gets the value of the bind property.
* @return
* possible object is {@link String }
*/
public String getBind() {
return bind;
}
/**
* Sets the value of the bind property.
* @param value
* allowed object is {@link String }
*/
public void setBind(String value) {
this.bind = value;
}
/**
* Gets the value of the unbind property.
* @return
* possible object is {@link String }
*/
public String getUnbind() {
return unbind;
}
/**
* Sets the value of the unbind property.
* @param value
* allowed object is {@link String }
*/
public void setUnbind(String value) {
this.unbind = value;
}
/**
* Gets the value of the exec property.
* @return
* possible object is {@link String }
*/
public String getExec() {
return exec;
}
/**
* Sets the value of the exec property.
* @param value
* allowed object is {@link String }
*/
public void setExec(String value) {
this.exec = value;
}
/**
* Gets the value of the all property.
* @return
* possible object is {@link String }
*/
public String getAll() {
return all;
}
/**
* Sets the value of the all property.
* @param value
* allowed object is {@link String }
*/
public void setAll(String value) {
this.all = value;
}
}
| 27.21831 | 97 | 0.560543 |
383a8991d3290835a2823a7a6c49bddda8def9ea | 4,609 | package com.example.android.miwok;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ListView;
import java.util.ArrayList;
import butterknife.BindView;
import butterknife.ButterKnife;
public class PhrasesActivity extends AppCompatActivity {
@BindView(R.id.list)
ListView listView;
MediaPlayer mediaPlayer;
Word word;
AudioManager.OnAudioFocusChangeListener afChangeListener;
private AudioManager mAudioManager;
MediaPlayer.OnCompletionListener onCompletionListener = mp -> releaseMediaPlayer();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.word_list);
//Audio Manager Focus
mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
afChangeListener = focusChange -> {
if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT ||
focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
// Pause playback because your Audio Focus was
mediaPlayer.pause();
mediaPlayer.seekTo(0);
} else if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
// Stop playback, because you lost the Audio Focus.// i.e. the user started some other playback app
releaseMediaPlayer();
} else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
// Resume playback, because you hold the Audio Focus
mediaPlayer.start();
}
};
// Create a list of words
ArrayList<Word> words = new ArrayList<>();
words.add(new Word(R.string.phrase_where_are_you_going,
R.string.miwok_phrase_where_are_you_going, R.raw.phrase_where_are_you_going));
words.add(new Word(R.string.phrase_what_is_your_name,
R.string.miwok_phrase_what_is_your_name, R.raw.phrase_what_is_your_name));
words.add(new Word(R.string.phrase_my_name_is,
R.string.miwok_phrase_my_name_is, R.raw.phrase_my_name_is));
words.add(new Word(R.string.phrase_how_are_you_feeling,
R.string.miwok_phrase_how_are_you_feeling, R.raw.phrase_how_are_you_feeling));
words.add(new Word(R.string.phrase_im_feeling_good,
R.string.miwok_phrase_im_feeling_good, R.raw.phrase_im_feeling_good));
words.add(new Word(R.string.phrase_are_you_coming,
R.string.miwok_phrase_are_you_coming, R.raw.phrase_are_you_coming));
words.add(new Word(R.string.phrase_yes_im_coming,
R.string.miwok_phrase_yes_im_coming, R.raw.phrase_yes_im_coming));
words.add(new Word(R.string.phrase_im_coming,
R.string.miwok_phrase_im_coming, R.raw.phrase_im_coming));
words.add(new Word(R.string.phrase_lets_go,
R.string.miwok_phrase_lets_go, R.raw.phrase_lets_go));
words.add(new Word(R.string.phrase_come_here,
R.string.miwok_phrase_come_here, R.raw.phrase_come_here));
//ButterKnife
ButterKnife.bind(this);
//Array Adapter
WordAdapter itemsAdapter = new WordAdapter(this, words, R.color.category_phrases);
listView.setAdapter(itemsAdapter);
listView.setOnItemClickListener((parent, view, position, id) -> {
word = words.get(position);
//release media player before creation
releaseMediaPlayer();
int result = mAudioManager.requestAudioFocus(afChangeListener,
// Use the music stream.
AudioManager.STREAM_NOTIFICATION,
// Request permanent focus.
AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
// Start playback
mediaPlayer = MediaPlayer.create(getApplicationContext(), word.getmAudioID());
mediaPlayer.start();
mediaPlayer.setOnCompletionListener(onCompletionListener);
}
});
}
// release media player
public void releaseMediaPlayer() {
if (mediaPlayer != null) {
mediaPlayer.release();
mediaPlayer = null;
mAudioManager.abandonAudioFocus(afChangeListener);
}
}
@Override
protected void onStop() {
super.onStop();
releaseMediaPlayer();
}
}
| 42.675926 | 115 | 0.659579 |
3962ec94c79e1de25eac07a43c3afc226658bc60 | 3,243 | package de.Hero.clickgui.elements.menu;
import java.awt.Color;
import me.lc.vodka.setting.Setting;
import net.minecraft.client.gui.Gui;
import net.minecraft.util.MathHelper;
import de.Hero.clickgui.elements.Element;
import de.Hero.clickgui.elements.ModuleButton;
import de.Hero.clickgui.util.ColorUtil;
import de.Hero.clickgui.util.FontUtil;
/**
* Made by HeroCode
* it's free to use
* but you have to credit me
*
* @author HeroCode
*/
public class ElementSlider extends Element {
public boolean dragging;
/*
* Konstrukor
*/
public ElementSlider(ModuleButton iparent, Setting iset) {
parent = iparent;
set = iset;
dragging = false;
super.setup();
}
/*
* Rendern des Elements
*/
public void drawScreen(int mouseX, int mouseY, float partialTicks) {
String displayval = "" + Math.round(set.getCurrentValue() * 100D)/ 100D;
boolean hoveredORdragged = isSliderHovered(mouseX, mouseY) || dragging;
Color temp = ColorUtil.getClickGUIColor();
int color = new Color(temp.getRed(), temp.getGreen(), temp.getBlue(), hoveredORdragged ? 250 : 200).getRGB();
int color2 = new Color(temp.getRed(), temp.getGreen(), temp.getBlue(), hoveredORdragged ? 255 : 230).getRGB();
//selected = iset.getValDouble() / iset.getMax();
double percentBar = (set.getCurrentValue() - set.getMinValue())/(set.getMaxValue() - set.getMinValue());
/*
* Die Box und Umrandung rendern
*/
Gui.drawRect((int)x, (int)y, (int)x + (int)width, (int)y + (int)height, 0xff1a1a1a);
/*
* Den Text rendern
*/
FontUtil.drawString(setstrg, (int)x + 1, (int)y + 2, 0xffffffff);
FontUtil.drawString(displayval, (int)x + (int)width - FontUtil.getStringWidth(displayval), (int)y + 2, 0xffffffff);
/*
* Den Slider rendern
*/
Gui.drawRect((int)x, (int)y + 12, (int)x + (int)width, (int)y + 13, 0xff101010);
Gui.drawRect((int)x, (int)y + 12, (int)x + (int)(percentBar * (int)width), (int)y + 13, color);
if(percentBar > 0 && percentBar < 1)
Gui.drawRect((int)x + ((int)percentBar * (int)width)-1, (int)y + 12, (int)x + (int)Math.min((percentBar * (int)width),(int) width), (int)y + 13, color2);
/*
* Neue Value berechnen, wenn dragging
*/
if (this.dragging) {
double diff = set.getMaxValue() - set.getMinValue();
double val = set.getMinValue() + (MathHelper.clamp_double((mouseX - x) / width, 0, 1)) * diff;
set.setCurrentValue(val); //Die Value im Setting updaten
}
}
/*
* 'true' oder 'false' bedeutet hat der Nutzer damit interagiert und
* sollen alle anderen Versuche der Interaktion abgebrochen werden?
*/
public boolean mouseClicked(int mouseX, int mouseY, int mouseButton) {
if (mouseButton == 0 && isSliderHovered(mouseX, mouseY)) {
this.dragging = true;
return true;
}
return super.mouseClicked(mouseX, mouseY, mouseButton);
}
/*
* Wenn die Maus losgelassen wird soll aufgeh�rt werden die Slidervalue zu ver�ndern
*/
public void mouseReleased(int mouseX, int mouseY, int state) {
this.dragging = false;
}
/*
* Einfacher HoverCheck, ben�tigt damit dragging auf true gesetzt werden kann
*/
public boolean isSliderHovered(int mouseX, int mouseY) {
return mouseX >= x && mouseX <= x + width && mouseY >= y + 11 && mouseY <= y + 14;
}
} | 30.885714 | 155 | 0.679618 |
bf6f2688ac916d598fe2fa9f0902f1971118ccfa | 738 | package com.aspose.pdf.examples.AsposePdfExamples.DocumentConversion;
import com.aspose.pdf.Document;
import com.aspose.pdf.HtmlSaveOptions;
public class PDFToHTMLAvoidSavingImagesInSVGFormat {
public static void main(String[] args) {
// Open source PDF document
Document pdfDocument = new Document("input.pdf");
String outHtmlFile = "resultant.html";
// Create HtmlSaveOption with tested feature
HtmlSaveOptions saveOptions = new HtmlSaveOptions();
saveOptions.setFixedLayout(true);
// save images in PNG format instead of SVG
saveOptions.RasterImagesSavingMode = HtmlSaveOptions.RasterImagesSavingModes.AsEmbeddedPartsOfPngPageBackground;
// save output as HTML
pdfDocument.save(outHtmlFile, saveOptions);
}
}
| 33.545455 | 114 | 0.798103 |
6b8bf1fffaec2a53cf1a56468983f869caf64c88 | 1,089 | package com.qdone.module.service;
import java.util.List;
import com.qdone.module.model.Staff;
import com.qdone.framework.core.page.PageList;
/**
* TODO 本代码由代码生成工具生成
*
* @author 付为地
* @date 2018-05-06 04:16:56
*/
public interface StaffService {
/**
* 分页查询
* @param entity
* @return
*/
public PageList<Staff> selectPage(Staff entity);
/**
* 新增
* @param object
* @return
*/
public int insert(Staff object) ;
/**
* 修改
* @param object
* @return
*/
public int update(Staff object) ;
/**
* 查看
* @param pk
* @return
*/
public Staff view(String pk) ;
/**
* 查询单个
* @param object
* @return
*/
public Staff query(Staff object) ;
/**
* 查询集合
* @param object
* @return
*/
public List<Staff> selectList(Staff object) ;
/**
* 删除
* @param pk
* @return
*/
public int delete(String pk);
/**
* 批量修改
* @param object
*/
public int batchUpdate(List<Staff> arr);
/**
* 批量插入
* @param object
*/
public int batchInsert(List<Staff> arr);
/**
* 批量删除
*/
public int batchDelete(List<Staff> pkList);
}
| 13.280488 | 49 | 0.596878 |
96684a00b11e6c959fcb2bcb6ad136b1650a34e6 | 80,806 | /*
* This file was automatically generated by EvoSuite
* Sun Nov 29 08:43:32 GMT 2020
*/
package com.werken.saxpath;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.runtime.EvoAssertions.*;
import com.werken.saxpath.Token;
import com.werken.saxpath.XPathLexer;
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, useJEE = true)
public class XPathLexer_ESTest extends XPathLexer_ESTest_scaffolding {
/**
//Test case number: 0
/*Coverage entropy=1.8937882323911377
*/
@Test(timeout = 4000)
public void test000() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(">4=iQRn>so");
Token token0 = xPathLexer0.relationalOperator();
assertEquals(9, token0.getTokenType());
assertEquals(">", token0.getTokenText());
assertNotNull(token0);
}
/**
//Test case number: 1
/*Coverage entropy=1.3761047605200099
*/
@Test(timeout = 4000)
public void test001() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.nextToken();
assertEquals("2", token0.getTokenText());
assertEquals(30, token0.getTokenType());
xPathLexer0.setXPath(". ovq.fYqWWRsz#1i");
Token token1 = xPathLexer0.star();
assertEquals(20, token1.getTokenType());
assertEquals(".", token1.getTokenText());
Token token2 = xPathLexer0.nextToken();
assertEquals("ovq.fYqWWRsz#1i", token2.getTokenText());
}
/**
//Test case number: 2
/*Coverage entropy=2.3693821196946767
*/
@Test(timeout = 4000)
public void test002() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
xPathLexer0.leftBracket();
xPathLexer0.comma();
xPathLexer0.dots();
Token token0 = xPathLexer0.or();
assertNull(token0);
}
/**
//Test case number: 3
/*Coverage entropy=1.9061547465398496
*/
@Test(timeout = 4000)
public void test003() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("a&aX;P[&/B[239oU");
Token token0 = xPathLexer0.and();
assertNull(token0);
}
/**
//Test case number: 4
/*Coverage entropy=2.1972245773362196
*/
@Test(timeout = 4000)
public void test004() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("$Zh+LUd d");
xPathLexer0.notEquals();
Token token0 = xPathLexer0.and();
assertNull(token0);
}
/**
//Test case number: 5
/*Coverage entropy=1.0651613418214507
*/
@Test(timeout = 4000)
public void test005() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
xPathLexer0.nextToken();
xPathLexer0.dollar();
xPathLexer0.star();
xPathLexer0.dots();
xPathLexer0.whitespace();
xPathLexer0.pipe();
Token token0 = xPathLexer0.div();
assertNull(token0);
}
/**
//Test case number: 6
/*Coverage entropy=0.7123333326585803
*/
@Test(timeout = 4000)
public void test006() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
xPathLexer0.nextToken();
Token token0 = xPathLexer0.div();
assertNull(token0);
}
/**
//Test case number: 7
/*Coverage entropy=0.8893347942937239
*/
@Test(timeout = 4000)
public void test007() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
xPathLexer0.minus();
xPathLexer0.colon();
xPathLexer0.plus();
xPathLexer0.nextToken();
xPathLexer0.doubleColon();
xPathLexer0.at();
xPathLexer0.plus();
Token token0 = xPathLexer0.mod();
assertNull(token0);
}
/**
//Test case number: 8
/*Coverage entropy=0.7164516354046382
*/
@Test(timeout = 4000)
public void test008() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setXPath("sI0!5iGJ{%b7j");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertNotNull(token0);
assertEquals("sI0", token0.getTokenText());
assertEquals(15, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("!", token1.getTokenText());
assertEquals(23, token1.getTokenType());
}
/**
//Test case number: 9
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test009() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Is`4C:xC");
xPathLexer0.consume();
assertEquals("Is`4C:xC", xPathLexer0.getXPath());
}
/**
//Test case number: 10
/*Coverage entropy=2.031759218569271
*/
@Test(timeout = 4000)
public void test010() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.literal();
assertNull(token0);
}
/**
//Test case number: 11
/*Coverage entropy=1.6094379124341005
*/
@Test(timeout = 4000)
public void test011() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
boolean boolean0 = xPathLexer0.hasMoreChars();
assertTrue(boolean0);
}
/**
//Test case number: 12
/*Coverage entropy=2.274474727098298
*/
@Test(timeout = 4000)
public void test012() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("com.werken.saxpath.XPathLexer", token0.getTokenText());
assertEquals(15, token0.getTokenType());
assertNotNull(token0);
boolean boolean0 = xPathLexer0.hasMoreChars();
assertFalse(boolean0);
}
/**
//Test case number: 13
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test013() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
String string0 = xPathLexer0.getXPath();
assertNull(string0);
}
/**
//Test case number: 14
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test014() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("AV\"l!LU0V[");
String string0 = xPathLexer0.getXPath();
assertEquals("AV\"l!LU0V[", string0);
}
/**
//Test case number: 15
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test015() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("*");
Token token0 = xPathLexer0.getPreviousToken();
assertNull(token0);
}
/**
//Test case number: 16
/*Coverage entropy=0.5338561348021286
*/
@Test(timeout = 4000)
public void test016() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.minus();
assertEquals("0", token0.getTokenText());
Token token1 = xPathLexer0.colon();
assertEquals(18, token1.getTokenType());
assertEquals("`", token1.getTokenText());
Token token2 = xPathLexer0.notEquals();
assertEquals("}`", token2.getTokenText());
assertEquals(22, token2.getTokenType());
xPathLexer0.nextToken();
Token token3 = xPathLexer0.getPreviousToken();
assertEquals(6, token3.getTokenType());
}
/**
//Test case number: 17
/*Coverage entropy=0.7596593632444977
*/
@Test(timeout = 4000)
public void test017() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.nextToken();
assertEquals(30, token0.getTokenType());
assertEquals("2", token0.getTokenText());
xPathLexer0.nextToken();
Token token1 = xPathLexer0.getPreviousToken();
assertEquals("~.mkbdWk06!1o", token1.getTokenText());
}
/**
//Test case number: 18
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test018() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
int int0 = xPathLexer0.endPosition();
assertEquals(0, int0);
}
/**
//Test case number: 19
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test019() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
int int0 = xPathLexer0.endPosition();
assertEquals(14, int0);
}
/**
//Test case number: 20
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test020() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
int int0 = xPathLexer0.currentPosition();
assertEquals(0, int0);
}
/**
//Test case number: 21
/*Coverage entropy=0.6755920761612467
*/
@Test(timeout = 4000)
public void test021() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.nextToken();
assertEquals(30, token0.getTokenType());
assertEquals("2", token0.getTokenText());
int int0 = xPathLexer0.currentPosition();
assertEquals(1, int0);
}
/**
//Test case number: 22
/*Coverage entropy=0.56217493659866
*/
@Test(timeout = 4000)
public void test022() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
Token token0 = xPathLexer0.star();
assertEquals(20, token0.getTokenType());
assertEquals("S", token0.getTokenText());
Token token1 = xPathLexer0.nextToken();
assertEquals(9, token1.getTokenType());
assertEquals(">", token1.getTokenText());
char char0 = xPathLexer0.LA(13);
assertEquals('\uFFFF', char0);
}
/**
//Test case number: 23
/*Coverage entropy=1.7917594692280547
*/
@Test(timeout = 4000)
public void test023() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
char char0 = xPathLexer0.LA(4);
assertEquals('D', char0);
}
/**
//Test case number: 24
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test024() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("!gPbw6YzW,M");
xPathLexer0.setXPath("");
String string0 = xPathLexer0.getXPath();
assertEquals("", string0);
}
/**
//Test case number: 25
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test025() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setPreviousToken((Token) null);
assertNull(xPathLexer0.getXPath());
}
/**
//Test case number: 26
/*Coverage entropy=1.0397207708399179
*/
@Test(timeout = 4000)
public void test026() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("!L%wh0f3Xl=aR");
boolean boolean0 = xPathLexer0.isIdentifierStartChar(':');
assertFalse(boolean0);
}
/**
//Test case number: 27
/*Coverage entropy=1.0397207708399179
*/
@Test(timeout = 4000)
public void test027() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("?<g)/.Aqe0Op;PK");
boolean boolean0 = xPathLexer0.isIdentifierStartChar('3');
assertFalse(boolean0);
}
/**
//Test case number: 28
/*Coverage entropy=1.0397207708399179
*/
@Test(timeout = 4000)
public void test028() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("*");
boolean boolean0 = xPathLexer0.isIdentifierStartChar('A');
assertTrue(boolean0);
}
/**
//Test case number: 29
/*Coverage entropy=0.5623351446188083
*/
@Test(timeout = 4000)
public void test029() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
boolean boolean0 = xPathLexer0.isIdentifierChar('<');
assertFalse(boolean0);
}
/**
//Test case number: 30
/*Coverage entropy=0.9502705392332347
*/
@Test(timeout = 4000)
public void test030() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("&-0Co- h\"-d:XW");
boolean boolean0 = xPathLexer0.isIdentifierChar('7');
assertTrue(boolean0);
}
/**
//Test case number: 31
/*Coverage entropy=0.9502705392332347
*/
@Test(timeout = 4000)
public void test031() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(") (");
boolean boolean0 = xPathLexer0.isIdentifierChar('Z');
assertTrue(boolean0);
}
/**
//Test case number: 32
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test032() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("");
xPathLexer0.consume(0);
assertEquals("", xPathLexer0.getXPath());
}
/**
//Test case number: 33
/*Coverage entropy=1.7917594692280547
*/
@Test(timeout = 4000)
public void test033() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
char char0 = xPathLexer0.LA(13);
assertEquals('4', char0);
}
/**
//Test case number: 34
/*Coverage entropy=2.2718685126965625
*/
@Test(timeout = 4000)
public void test034() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
xPathLexer0.consume((-212));
// Undeclared exception!
try {
xPathLexer0.whitespace();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 35
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test035() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
// Undeclared exception!
try {
xPathLexer0.setXPath((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 36
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test036() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
xPathLexer0.consume((-2137));
// Undeclared exception!
try {
xPathLexer0.relationalOperator();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 37
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test037() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("V\"l!0V");
xPathLexer0.consume((-1));
// Undeclared exception!
try {
xPathLexer0.or();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 38
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test038() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-2125));
// Undeclared exception!
try {
xPathLexer0.operatorName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 39
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test039() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(">Bw)+S5.9BL,j$1m");
xPathLexer0.consume((-1959));
// Undeclared exception!
try {
xPathLexer0.number();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 40
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test040() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-2515));
// Undeclared exception!
try {
xPathLexer0.number();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 41
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test041() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
xPathLexer0.consume((-241));
// Undeclared exception!
try {
xPathLexer0.nextToken();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 42
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test042() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-1096));
// Undeclared exception!
try {
xPathLexer0.nextToken();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 43
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test043() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("AV\"l!LU0V[");
xPathLexer0.consume((-1));
// Undeclared exception!
try {
xPathLexer0.mod();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 44
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test044() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-1));
// Undeclared exception!
try {
xPathLexer0.mod();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 45
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test045() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("!L%wh0f3Xl=aR");
xPathLexer0.consume((-1815));
// Undeclared exception!
try {
xPathLexer0.literal();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 46
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test046() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-4880));
// Undeclared exception!
try {
xPathLexer0.literal();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 47
/*Coverage entropy=2.351673301904631
*/
@Test(timeout = 4000)
public void test047() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Is`4C:xC");
xPathLexer0.consume((-192));
// Undeclared exception!
try {
xPathLexer0.identifierOrOperatorName();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 48
/*Coverage entropy=2.2538575896013526
*/
@Test(timeout = 4000)
public void test048() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-1168));
// Undeclared exception!
try {
xPathLexer0.identifierOrOperatorName();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 49
/*Coverage entropy=2.1639556568820564
*/
@Test(timeout = 4000)
public void test049() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("yX:V");
xPathLexer0.consume((-1732));
// Undeclared exception!
try {
xPathLexer0.identifier();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 50
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test050() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Cs{l'LLGYY0r#b");
xPathLexer0.consume((-1366));
// Undeclared exception!
try {
xPathLexer0.dots();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 51
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test051() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(".9Eb]");
xPathLexer0.consume((-1));
// Undeclared exception!
try {
xPathLexer0.div();
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 52
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test052() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-636));
// Undeclared exception!
try {
xPathLexer0.div();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 53
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test053() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.consume((-1179));
// Undeclared exception!
try {
xPathLexer0.and();
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 54
/*Coverage entropy=1.7917594692280547
*/
@Test(timeout = 4000)
public void test054() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
// Undeclared exception!
try {
xPathLexer0.LA((-179));
fail("Expecting exception: StringIndexOutOfBoundsException");
} catch(StringIndexOutOfBoundsException e) {
}
}
/**
//Test case number: 55
/*Coverage entropy=1.6094379124341005
*/
@Test(timeout = 4000)
public void test055() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
// Undeclared exception!
try {
xPathLexer0.LA(0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 56
/*Coverage entropy=0.6931471805599453
*/
@Test(timeout = 4000)
public void test056() throws Throwable {
XPathLexer xPathLexer0 = null;
try {
xPathLexer0 = new XPathLexer((String) null);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
/**
//Test case number: 57
/*Coverage entropy=2.0636495704788542
*/
@Test(timeout = 4000)
public void test057() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("5CfC9ufG-;z4[kYQ%JW");
Token token0 = xPathLexer0.identifier();
assertEquals("5CfC9ufG-", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 58
/*Coverage entropy=2.0431918705451206
*/
@Test(timeout = 4000)
public void test058() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.slashes();
assertEquals("i/", token0.getTokenText());
assertEquals(12, token0.getTokenType());
}
/**
//Test case number: 59
/*Coverage entropy=1.8310204811135162
*/
@Test(timeout = 4000)
public void test059() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.relationalOperator();
assertNull(token0);
}
/**
//Test case number: 60
/*Coverage entropy=2.0794415416798357
*/
@Test(timeout = 4000)
public void test060() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("");
Token token0 = xPathLexer0.whitespace();
assertEquals((-2), token0.getTokenType());
}
/**
//Test case number: 61
/*Coverage entropy=1.551888093566232
*/
@Test(timeout = 4000)
public void test061() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(">9j*..Zk4m<{LS7i*");
Token token0 = xPathLexer0.doubleColon();
assertEquals(">9", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.pipe();
assertEquals("j", token1.getTokenText());
assertEquals(17, token1.getTokenType());
Token token2 = xPathLexer0.not();
assertEquals("*", token2.getTokenText());
assertEquals(23, token2.getTokenType());
Token token3 = xPathLexer0.number();
assertEquals(31, token3.getTokenType());
assertEquals(".", token3.getTokenText());
}
/**
//Test case number: 62
/*Coverage entropy=1.411642334512242
*/
@Test(timeout = 4000)
public void test062() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.not();
assertEquals(23, token0.getTokenType());
assertEquals("i", token0.getTokenText());
Token token1 = xPathLexer0.number();
assertEquals(30, token1.getTokenType());
assertEquals("", token1.getTokenText());
}
/**
//Test case number: 63
/*Coverage entropy=2.3025850929940455
*/
@Test(timeout = 4000)
public void test063() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
xPathLexer0.leftBracket();
xPathLexer0.comma();
Token token0 = xPathLexer0.or();
assertNull(token0);
}
/**
//Test case number: 64
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test064() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.and();
assertNull(token0);
}
/**
//Test case number: 65
/*Coverage entropy=1.494079002889399
*/
@Test(timeout = 4000)
public void test065() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("f4di7y%");
Token token0 = xPathLexer0.rightBracket();
xPathLexer0.setPreviousToken(token0);
xPathLexer0.star();
Token token1 = xPathLexer0.identifierOrOperatorName();
assertNull(token1);
}
/**
//Test case number: 66
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test066() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.div();
assertNull(token0);
}
/**
//Test case number: 67
/*Coverage entropy=1.945910149055313
*/
@Test(timeout = 4000)
public void test067() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("vIfmZQY.A+V:");
Token token0 = xPathLexer0.mod();
assertNull(token0);
}
/**
//Test case number: 68
/*Coverage entropy=2.0791512728828505
*/
@Test(timeout = 4000)
public void test068() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
xPathLexer0.rightParen();
Token token0 = xPathLexer0.operatorName();
assertNull(token0);
}
/**
//Test case number: 69
/*Coverage entropy=2.3662893177133655
*/
@Test(timeout = 4000)
public void test069() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("zu*paj_h^'");
xPathLexer0.minus();
xPathLexer0.rightBracket();
xPathLexer0.pipe();
xPathLexer0.not();
Token token0 = xPathLexer0.operatorName();
assertNull(token0);
}
/**
//Test case number: 70
/*Coverage entropy=1.1931883257219056
*/
@Test(timeout = 4000)
public void test070() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(":1%1ga");
xPathLexer0.rightParen();
xPathLexer0.identifierOrOperatorName();
xPathLexer0.nextToken();
Token token0 = xPathLexer0.identifierOrOperatorName();
assertNull(token0);
}
/**
//Test case number: 71
/*Coverage entropy=1.088065144454542
*/
@Test(timeout = 4000)
public void test071() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setXPath("yx,qR{MH");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("yx", token0.getTokenText());
Token token1 = xPathLexer0.nextToken();
assertEquals(32, token1.getTokenType());
assertEquals(",", token1.getTokenText());
Token token2 = xPathLexer0.nextToken();
assertEquals(15, token2.getTokenType());
assertEquals("qR", token2.getTokenText());
}
/**
//Test case number: 72
/*Coverage entropy=1.1797269776294952
*/
@Test(timeout = 4000)
public void test072() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.leftParen();
assertEquals("0", token0.getTokenText());
assertEquals(1, token0.getTokenType());
Token token1 = xPathLexer0.minus();
assertEquals("`", token1.getTokenText());
assertEquals(6, token1.getTokenType());
Token token2 = xPathLexer0.notEquals();
assertEquals("}`", token2.getTokenText());
assertEquals(22, token2.getTokenType());
Token token3 = xPathLexer0.dollar();
xPathLexer0.setPreviousToken(token3);
assertEquals(26, token3.getTokenType());
assertEquals("-", token3.getTokenText());
Token token4 = xPathLexer0.nextToken();
assertEquals("hSq5", token4.getTokenText());
assertEquals(15, token4.getTokenType());
}
/**
//Test case number: 73
/*Coverage entropy=1.532954812744937
*/
@Test(timeout = 4000)
public void test073() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.notEquals();
xPathLexer0.setPreviousToken(token0);
assertEquals(22, token0.getTokenType());
assertEquals("co", token0.getTokenText());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals("m.werken.saxpath.XPathLexer", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 74
/*Coverage entropy=1.0592746830785
*/
@Test(timeout = 4000)
public void test074() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
Token token0 = xPathLexer0.equals();
xPathLexer0.setPreviousToken(token0);
assertEquals(21, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 75
/*Coverage entropy=1.4204552241466717
*/
@Test(timeout = 4000)
public void test075() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
Token token0 = xPathLexer0.star();
xPathLexer0.setPreviousToken(token0);
assertEquals("P", token0.getTokenText());
assertEquals(20, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
assertEquals("", token1.getTokenText());
}
/**
//Test case number: 76
/*Coverage entropy=1.4204552241466717
*/
@Test(timeout = 4000)
public void test076() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.doubleColon();
xPathLexer0.setPreviousToken(token0);
assertEquals("i/", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals("", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 77
/*Coverage entropy=1.4204552241466717
*/
@Test(timeout = 4000)
public void test077() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(")`");
Token token0 = xPathLexer0.pipe();
xPathLexer0.setPreviousToken(token0);
assertEquals(")", token0.getTokenText());
assertEquals(17, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals("", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 78
/*Coverage entropy=1.0592746830785
*/
@Test(timeout = 4000)
public void test078() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
Token token0 = xPathLexer0.at();
xPathLexer0.setPreviousToken(token0);
assertEquals(16, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 79
/*Coverage entropy=1.0224103852247368
*/
@Test(timeout = 4000)
public void test079() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(">9j*..Zk4m<{LS7i*");
Token token0 = xPathLexer0.doubleColon();
assertEquals(">9", token0.getTokenText());
Token token1 = xPathLexer0.doubleColon();
assertEquals(19, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals(14, token2.getTokenType());
assertEquals("..", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals("Zk4m<{LS7i*", token3.getTokenText());
}
/**
//Test case number: 80
/*Coverage entropy=1.195679235156794
*/
@Test(timeout = 4000)
public void test080() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
Token token0 = xPathLexer0.minus();
assertEquals("P", token0.getTokenText());
assertEquals(6, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(7, token1.getTokenType());
assertEquals("<", token1.getTokenText());
Token token2 = xPathLexer0.doubleColon();
assertEquals("<D", token2.getTokenText());
assertEquals(19, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("XyC4n37b", token3.getTokenText());
}
/**
//Test case number: 81
/*Coverage entropy=1.4204552241466717
*/
@Test(timeout = 4000)
public void test081() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.minus();
xPathLexer0.setPreviousToken(token0);
assertEquals(6, token0.getTokenType());
assertEquals("0", token0.getTokenText());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
assertEquals("", token1.getTokenText());
}
/**
//Test case number: 82
/*Coverage entropy=1.1423012045047758
*/
@Test(timeout = 4000)
public void test082() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(")");
Token token0 = xPathLexer0.plus();
xPathLexer0.setPreviousToken(token0);
assertEquals(5, token0.getTokenType());
assertEquals(")", token0.getTokenText());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
assertEquals("", token1.getTokenText());
}
/**
//Test case number: 83
/*Coverage entropy=1.4204552241466717
*/
@Test(timeout = 4000)
public void test083() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(")`");
Token token0 = xPathLexer0.leftBracket();
xPathLexer0.setPreviousToken(token0);
assertEquals(")", token0.getTokenText());
assertEquals(3, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
assertEquals("", token1.getTokenText());
}
/**
//Test case number: 84
/*Coverage entropy=1.28072953486328
*/
@Test(timeout = 4000)
public void test084() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.rightParen();
xPathLexer0.setPreviousToken(token0);
Token token1 = xPathLexer0.identifierOrOperatorName();
assertNull(token1);
}
/**
//Test case number: 85
/*Coverage entropy=1.0592746830785
*/
@Test(timeout = 4000)
public void test085() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
Token token0 = xPathLexer0.leftParen();
xPathLexer0.setPreviousToken(token0);
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals(15, token1.getTokenType());
assertNotNull(token1);
}
/**
//Test case number: 86
/*Coverage entropy=1.1314329367791054
*/
@Test(timeout = 4000)
public void test086() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(".9Eb]");
xPathLexer0.nextToken();
Token token0 = xPathLexer0.identifierOrOperatorName();
assertNull(token0);
}
/**
//Test case number: 87
/*Coverage entropy=0.4063317134016294
*/
@Test(timeout = 4000)
public void test087() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("::%cg.a");
Token token0 = xPathLexer0.nextToken();
assertEquals(19, token0.getTokenType());
assertEquals("::", token0.getTokenText());
}
/**
//Test case number: 88
/*Coverage entropy=0.4511636006386335
*/
@Test(timeout = 4000)
public void test088() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("q@]|");
Token token0 = xPathLexer0.pipe();
assertEquals("q", token0.getTokenText());
Token token1 = xPathLexer0.doubleColon();
assertEquals("@]", token1.getTokenText());
assertEquals(19, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals(17, token2.getTokenType());
}
/**
//Test case number: 89
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test089() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setXPath("sI0!GJ{%b7j");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("sI0", token0.getTokenText());
Token token1 = xPathLexer0.at();
assertEquals("!", token1.getTokenText());
assertEquals(16, token1.getTokenType());
Token token2 = xPathLexer0.identifierOrOperatorName();
assertEquals("GJ", token2.getTokenText());
assertEquals(15, token2.getTokenType());
assertNotNull(token2);
Token token3 = xPathLexer0.nextToken();
assertEquals("{%b7j", token3.getTokenText());
}
/**
//Test case number: 90
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test090() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("z(g+");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("z", token0.getTokenText());
}
/**
//Test case number: 91
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test091() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
xPathLexer0.setXPath("xT:fV!fWFEyAnBy");
Token token0 = xPathLexer0.nextToken();
assertEquals("xT", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 92
/*Coverage entropy=0.8822117420464162
*/
@Test(timeout = 4000)
public void test092() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
xPathLexer0.setXPath(". ovq.fYqWWRsz#1i");
Token token0 = xPathLexer0.star();
assertEquals(".", token0.getTokenText());
Token token1 = xPathLexer0.star();
assertEquals(20, token1.getTokenType());
Token token2 = xPathLexer0.dots();
assertEquals(13, token2.getTokenType());
assertEquals("o", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("vq.fYqWWRsz", token3.getTokenText());
}
/**
//Test case number: 93
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test093() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("u7fn&");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("u7fn", token0.getTokenText());
}
/**
//Test case number: 94
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test094() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("u3tjU8*F");
Token token0 = xPathLexer0.doubleColon();
assertEquals("u3", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("tjU8", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 95
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test095() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setXPath("sI0!GJ{%b7j");
Token token0 = xPathLexer0.nextToken();
assertEquals("sI0", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 96
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test096() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("rJKz%sDOp\"~f*3\"hdDM");
Token token0 = xPathLexer0.nextToken();
assertEquals("rJKz", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 97
/*Coverage entropy=0.9845431176802956
*/
@Test(timeout = 4000)
public void test097() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.leftParen();
assertEquals("0", token0.getTokenText());
assertEquals(1, token0.getTokenType());
Token token1 = xPathLexer0.minus();
assertEquals("`", token1.getTokenText());
assertEquals(6, token1.getTokenType());
Token token2 = xPathLexer0.colon();
assertEquals(18, token2.getTokenType());
assertEquals("}", token2.getTokenText());
Token token3 = xPathLexer0.notEquals();
assertEquals("`-", token3.getTokenText());
assertEquals(22, token3.getTokenType());
Token token4 = xPathLexer0.slashes();
assertEquals(11, token4.getTokenType());
assertEquals("h", token4.getTokenText());
Token token5 = xPathLexer0.dollar();
assertEquals(26, token5.getTokenType());
assertEquals("S", token5.getTokenText());
Token token6 = xPathLexer0.nextToken();
assertEquals("q5", token6.getTokenText());
assertEquals(15, token6.getTokenType());
}
/**
//Test case number: 98
/*Coverage entropy=0.7711904826943476
*/
@Test(timeout = 4000)
public void test098() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("pO");
Token token0 = xPathLexer0.nextToken();
assertEquals("pO", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 99
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test099() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("n'");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("n", token0.getTokenText());
}
/**
//Test case number: 100
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test100() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("l<SoNp)V!S-EV>y7k");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("l", token0.getTokenText());
}
/**
//Test case number: 101
/*Coverage entropy=1.2628280210485965
*/
@Test(timeout = 4000)
public void test101() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.nextToken();
assertEquals("2", token0.getTokenText());
assertEquals(30, token0.getTokenType());
Token token1 = xPathLexer0.dots();
assertEquals(14, token1.getTokenType());
assertEquals("~.", token1.getTokenText());
Token token2 = xPathLexer0.at();
assertEquals(16, token2.getTokenType());
assertEquals("m", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals("kbdWk06!1o", token3.getTokenText());
}
/**
//Test case number: 102
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test102() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(">9j*..Zk4m<{LS7i*");
Token token0 = xPathLexer0.doubleColon();
assertEquals(19, token0.getTokenType());
assertEquals(">9", token0.getTokenText());
Token token1 = xPathLexer0.nextToken();
assertEquals("j", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 103
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test103() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("i", token0.getTokenText());
}
/**
//Test case number: 104
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test104() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("gt}(w9}LySbq=");
Token token0 = xPathLexer0.nextToken();
assertEquals("gt", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 105
/*Coverage entropy=0.8441138774034159
*/
@Test(timeout = 4000)
public void test105() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("vIfmZQY.A+V:");
xPathLexer0.setXPath("qJg!Xf$f6OJ8>|p");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("qJg", token0.getTokenText());
Token token1 = xPathLexer0.star();
assertEquals(20, token1.getTokenType());
assertEquals("!", token1.getTokenText());
Token token2 = xPathLexer0.dots();
assertEquals("X", token2.getTokenText());
assertEquals(13, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("f", token3.getTokenText());
}
/**
//Test case number: 106
/*Coverage entropy=0.8106536471487246
*/
@Test(timeout = 4000)
public void test106() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("com.werken.saxpath.XPathLexer", token0.getTokenText());
}
/**
//Test case number: 107
/*Coverage entropy=0.9548711307083797
*/
@Test(timeout = 4000)
public void test107() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("!gPbw6YzW,M");
Token token0 = xPathLexer0.comma();
assertEquals(32, token0.getTokenType());
assertEquals("!", token0.getTokenText());
Token token1 = xPathLexer0.whitespace();
assertEquals("", token1.getTokenText());
assertEquals((-2), token1.getTokenType());
Token token2 = xPathLexer0.equals();
assertEquals("P", token2.getTokenText());
assertEquals(21, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("bw6YzW", token3.getTokenText());
}
/**
//Test case number: 108
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test108() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("garhdhZcmZ'&)");
Token token0 = xPathLexer0.star();
assertEquals("g", token0.getTokenText());
assertEquals(20, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("arhdhZcmZ", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 109
/*Coverage entropy=0.47912630415561397
*/
@Test(timeout = 4000)
public void test109() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(")`");
Token token0 = xPathLexer0.leftBracket();
assertEquals(")", token0.getTokenText());
assertEquals(3, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("`", token1.getTokenText());
assertEquals((-1), token1.getTokenType());
}
/**
//Test case number: 110
/*Coverage entropy=0.7164516354046382
*/
@Test(timeout = 4000)
public void test110() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("_r~Sr'/kRYV");
Token token0 = xPathLexer0.nextToken();
assertEquals("_r", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 111
/*Coverage entropy=0.3955852454859713
*/
@Test(timeout = 4000)
public void test111() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("^`eB");
Token token0 = xPathLexer0.nextToken();
assertEquals("^`eB", token0.getTokenText());
}
/**
//Test case number: 112
/*Coverage entropy=0.4511636006386335
*/
@Test(timeout = 4000)
public void test112() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(".9Eb]");
Token token0 = xPathLexer0.doubleColon();
assertEquals(".9", token0.getTokenText());
Token token1 = xPathLexer0.doubleColon();
assertEquals(19, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals(4, token2.getTokenType());
assertEquals("]", token2.getTokenText());
}
/**
//Test case number: 113
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test113() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Y@!ko&cG$pFH90HE");
Token token0 = xPathLexer0.nextToken();
assertEquals("Y", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 114
/*Coverage entropy=0.7722458213295293
*/
@Test(timeout = 4000)
public void test114() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("W9[9GFtX");
Token token0 = xPathLexer0.nextToken();
assertEquals("W9", token0.getTokenText());
assertEquals(15, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("[", token1.getTokenText());
assertEquals(3, token1.getTokenType());
}
/**
//Test case number: 115
/*Coverage entropy=1.3073262110826303
*/
@Test(timeout = 4000)
public void test115() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.minus();
assertEquals("0", token0.getTokenText());
assertEquals(6, token0.getTokenType());
xPathLexer0.colon();
Token token1 = xPathLexer0.notEquals();
assertEquals("}`", token1.getTokenText());
assertEquals(22, token1.getTokenType());
Token token2 = xPathLexer0.slashes();
assertEquals(11, token2.getTokenType());
assertEquals("-", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("hSq5", token3.getTokenText());
Token token4 = xPathLexer0.doubleColon();
assertEquals("{L", token4.getTokenText());
assertEquals(19, token4.getTokenType());
Token token5 = xPathLexer0.colon();
assertEquals("d", token5.getTokenText());
assertEquals(18, token5.getTokenType());
Token token6 = xPathLexer0.nextToken();
assertEquals((-1), token6.getTokenType());
assertEquals("VG1", token6.getTokenText());
}
/**
//Test case number: 116
/*Coverage entropy=0.938920547810086
*/
@Test(timeout = 4000)
public void test116() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("XpEAI%X0TEUdb\"^G3");
Token token0 = xPathLexer0.literal();
assertEquals("pEAI%", token0.getTokenText());
assertEquals(27, token0.getTokenType());
Token token1 = xPathLexer0.pipe();
assertEquals(17, token1.getTokenType());
assertEquals("0", token1.getTokenText());
Token token2 = xPathLexer0.doubleColon();
assertEquals(19, token2.getTokenType());
assertEquals("TE", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("Udb", token3.getTokenText());
}
/**
//Test case number: 117
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test117() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
Token token0 = xPathLexer0.nextToken();
assertEquals("S", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 118
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test118() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("R8NKaiaz<4W");
Token token0 = xPathLexer0.nextToken();
assertEquals("R8NKaiaz", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 119
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test119() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Q\"Zhq~#9?H1`{:68}");
Token token0 = xPathLexer0.nextToken();
assertEquals("Q", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 120
/*Coverage entropy=0.8508015905993925
*/
@Test(timeout = 4000)
public void test120() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("P", token0.getTokenText());
Token token1 = xPathLexer0.relationalOperator();
assertEquals(7, token1.getTokenType());
assertEquals("<", token1.getTokenText());
assertNotNull(token1);
}
/**
//Test case number: 121
/*Coverage entropy=0.8078856237959416
*/
@Test(timeout = 4000)
public void test121() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("7N07");
Token token0 = xPathLexer0.leftBracket();
assertEquals("7", token0.getTokenText());
assertEquals(3, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("N07", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 122
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test122() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("MOm*/nFj6");
Token token0 = xPathLexer0.nextToken();
assertEquals("MOm", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 123
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test123() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("K~'!7F$IoMqVK#kl");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("K", token0.getTokenText());
}
/**
//Test case number: 124
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test124() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("J?T:*A*`J39-+T9");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("J", token0.getTokenText());
}
/**
//Test case number: 125
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test125() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("Io&au#tZ'c_&LV6)}");
Token token0 = xPathLexer0.nextToken();
assertEquals("Io", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 126
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test126() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("H{g@)@uTR_vj%C9");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("H", token0.getTokenText());
}
/**
//Test case number: 127
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test127() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer();
xPathLexer0.setXPath("sI0!GJ{%b7j");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("sI0", token0.getTokenText());
Token token1 = xPathLexer0.plus();
assertEquals("!", token1.getTokenText());
assertEquals(5, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals(15, token2.getTokenType());
assertEquals("GJ", token2.getTokenText());
}
/**
//Test case number: 128
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test128() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("F+OSmu=qZ");
Token token0 = xPathLexer0.nextToken();
assertEquals("F", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 129
/*Coverage entropy=0.9041532818057841
*/
@Test(timeout = 4000)
public void test129() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("XpEAI%X0TEUdb\"^G3");
Token token0 = xPathLexer0.literal();
assertEquals(27, token0.getTokenType());
assertEquals("pEAI%", token0.getTokenText());
Token token1 = xPathLexer0.pipe();
assertEquals(17, token1.getTokenType());
assertEquals("0", token1.getTokenText());
Token token2 = xPathLexer0.nextToken();
assertEquals(15, token2.getTokenType());
assertEquals("TEUdb", token2.getTokenText());
}
/**
//Test case number: 130
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test130() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("D8uRC?J177S{");
Token token0 = xPathLexer0.nextToken();
assertEquals(15, token0.getTokenType());
assertEquals("D8uRC", token0.getTokenText());
}
/**
//Test case number: 131
/*Coverage entropy=0.7810925852737755
*/
@Test(timeout = 4000)
public void test131() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("DvCm;))>7&v'");
Token token0 = xPathLexer0.doubleColon();
assertEquals(19, token0.getTokenType());
assertEquals("Dv", token0.getTokenText());
Token token1 = xPathLexer0.nextToken();
assertEquals("Cm", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 132
/*Coverage entropy=0.7439920825769217
*/
@Test(timeout = 4000)
public void test132() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("B~zg}hUPC)");
Token token0 = xPathLexer0.nextToken();
assertEquals("B", token0.getTokenText());
assertEquals(15, token0.getTokenType());
}
/**
//Test case number: 133
/*Coverage entropy=0.4089388914174921
*/
@Test(timeout = 4000)
public void test133() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("@^`");
Token token0 = xPathLexer0.nextToken();
assertEquals("@", token0.getTokenText());
assertEquals(16, token0.getTokenType());
}
/**
//Test case number: 134
/*Coverage entropy=0.7503520167076843
*/
@Test(timeout = 4000)
public void test134() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("ye?/O");
Token token0 = xPathLexer0.nextToken();
assertEquals("ye", token0.getTokenText());
assertEquals(15, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("?/O", token1.getTokenText());
}
/**
//Test case number: 135
/*Coverage entropy=0.4089388914174921
*/
@Test(timeout = 4000)
public void test135() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("=d!zeK3#(<M3");
Token token0 = xPathLexer0.nextToken();
assertEquals("=", token0.getTokenText());
assertEquals(21, token0.getTokenType());
}
/**
//Test case number: 136
/*Coverage entropy=0.661096315970889
*/
@Test(timeout = 4000)
public void test136() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("i/ ;hA*)P<F{q");
Token token0 = xPathLexer0.doubleColon();
assertEquals("i/", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(";hA*)P<F{q", token1.getTokenText());
}
/**
//Test case number: 137
/*Coverage entropy=1.04232472198334
*/
@Test(timeout = 4000)
public void test137() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(":1%1ga");
Token token0 = xPathLexer0.nextToken();
assertEquals(":", token0.getTokenText());
assertEquals(18, token0.getTokenType());
Token token1 = xPathLexer0.identifierOrOperatorName();
assertEquals("1", token1.getTokenText());
assertEquals(15, token1.getTokenType());
}
/**
//Test case number: 138
/*Coverage entropy=1.3215187929453711
*/
@Test(timeout = 4000)
public void test138() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
Token token0 = xPathLexer0.minus();
assertEquals("S", token0.getTokenText());
assertEquals(6, token0.getTokenType());
Token token1 = xPathLexer0.colon();
assertEquals(">", token1.getTokenText());
assertEquals(18, token1.getTokenType());
xPathLexer0.plus();
Token token2 = xPathLexer0.nextToken();
assertEquals("9", token2.getTokenText());
assertEquals(30, token2.getTokenType());
Token token3 = xPathLexer0.doubleColon();
assertEquals(19, token3.getTokenType());
assertEquals("kH", token3.getTokenText());
Token token4 = xPathLexer0.at();
assertEquals("v", token4.getTokenText());
assertEquals(16, token4.getTokenType());
Token token5 = xPathLexer0.plus();
assertEquals(5, token5.getTokenType());
assertEquals("m", token5.getTokenText());
Token token6 = xPathLexer0.nextToken();
assertNotSame(token6, token2);
}
/**
//Test case number: 139
/*Coverage entropy=0.7123333326585803
*/
@Test(timeout = 4000)
public void test139() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("y8ewz4c,vB<7G@E7~");
Token token0 = xPathLexer0.star();
assertEquals("y", token0.getTokenText());
assertEquals(20, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("8", token1.getTokenText());
assertEquals(30, token1.getTokenType());
}
/**
//Test case number: 140
/*Coverage entropy=0.6755920761612467
*/
@Test(timeout = 4000)
public void test140() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("7TKr");
Token token0 = xPathLexer0.nextToken();
assertEquals(30, token0.getTokenType());
assertEquals("7", token0.getTokenText());
}
/**
//Test case number: 141
/*Coverage entropy=0.6755920761612467
*/
@Test(timeout = 4000)
public void test141() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("6tM]zK5tN8CE mwz\"");
Token token0 = xPathLexer0.nextToken();
assertEquals("6", token0.getTokenText());
assertEquals(30, token0.getTokenType());
}
/**
//Test case number: 142
/*Coverage entropy=0.9479857335220208
*/
@Test(timeout = 4000)
public void test142() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.leftParen();
assertEquals(1, token0.getTokenType());
assertEquals("0", token0.getTokenText());
Token token1 = xPathLexer0.minus();
assertEquals("`", token1.getTokenText());
assertEquals(6, token1.getTokenType());
Token token2 = xPathLexer0.colon();
assertEquals("}", token2.getTokenText());
assertEquals(18, token2.getTokenType());
Token token3 = xPathLexer0.notEquals();
assertEquals("`-", token3.getTokenText());
assertEquals(22, token3.getTokenType());
Token token4 = xPathLexer0.slashes();
assertEquals(11, token4.getTokenType());
assertEquals("h", token4.getTokenText());
Token token5 = xPathLexer0.dollar();
assertEquals("S", token5.getTokenText());
assertEquals(26, token5.getTokenType());
Token token6 = xPathLexer0.star();
assertEquals(20, token6.getTokenType());
Token token7 = xPathLexer0.nextToken();
assertEquals(30, token7.getTokenType());
assertEquals("5", token7.getTokenText());
}
/**
//Test case number: 143
/*Coverage entropy=0.7224512677116045
*/
@Test(timeout = 4000)
public void test143() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("390");
Token token0 = xPathLexer0.nextToken();
assertEquals("390", token0.getTokenText());
assertEquals(30, token0.getTokenType());
}
/**
//Test case number: 144
/*Coverage entropy=0.7123333326585803
*/
@Test(timeout = 4000)
public void test144() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(":1%1ga");
Token token0 = xPathLexer0.leftParen();
assertEquals(":", token0.getTokenText());
assertEquals(1, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("1", token1.getTokenText());
assertEquals(30, token1.getTokenType());
}
/**
//Test case number: 145
/*Coverage entropy=0.6755920761612467
*/
@Test(timeout = 4000)
public void test145() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("0`}`-hSq5{LdVG1");
Token token0 = xPathLexer0.nextToken();
assertEquals(30, token0.getTokenType());
assertEquals("0", token0.getTokenText());
}
/**
//Test case number: 146
/*Coverage entropy=1.0085797994064658
*/
@Test(timeout = 4000)
public void test146() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("@/");
Token token0 = xPathLexer0.star();
assertEquals("@", token0.getTokenText());
assertEquals(20, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("/", token1.getTokenText());
assertEquals(11, token1.getTokenType());
Token token2 = xPathLexer0.identifierOrOperatorName();
assertEquals("", token2.getTokenText());
assertEquals(15, token2.getTokenType());
}
/**
//Test case number: 147
/*Coverage entropy=1.151721681553245
*/
@Test(timeout = 4000)
public void test147() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
Token token0 = xPathLexer0.star();
assertEquals("S", token0.getTokenText());
assertEquals(20, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(">", token1.getTokenText());
assertEquals(9, token1.getTokenType());
Token token2 = xPathLexer0.identifierOrOperatorName();
assertEquals("X9kHvmOaR", token2.getTokenText());
assertEquals(15, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(32, token3.getTokenType());
assertEquals(",", token3.getTokenText());
}
/**
//Test case number: 148
/*Coverage entropy=0.5323407625503742
*/
@Test(timeout = 4000)
public void test148() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("J+<TkB|t,h=");
Token token0 = xPathLexer0.doubleColon();
assertEquals("J+", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(7, token1.getTokenType());
assertEquals("<", token1.getTokenText());
}
/**
//Test case number: 149
/*Coverage entropy=0.4089388914174921
*/
@Test(timeout = 4000)
public void test149() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("*'");
Token token0 = xPathLexer0.nextToken();
assertEquals(20, token0.getTokenType());
assertEquals("*", token0.getTokenText());
}
/**
//Test case number: 150
/*Coverage entropy=0.4089388914174921
*/
@Test(timeout = 4000)
public void test150() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer(") (");
Token token0 = xPathLexer0.nextToken();
assertEquals(2, token0.getTokenType());
assertEquals(")", token0.getTokenText());
}
/**
//Test case number: 151
/*Coverage entropy=0.4511636006386335
*/
@Test(timeout = 4000)
public void test151() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("[ (");
Token token0 = xPathLexer0.doubleColon();
assertEquals("[ ", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(1, token1.getTokenType());
assertEquals("(", token1.getTokenText());
}
/**
//Test case number: 152
/*Coverage entropy=0.56217493659866
*/
@Test(timeout = 4000)
public void test152() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("'2YB4");
Token token0 = xPathLexer0.nextToken();
assertEquals((-1), token0.getTokenType());
assertEquals("", token0.getTokenText());
}
/**
//Test case number: 153
/*Coverage entropy=0.3955852454859713
*/
@Test(timeout = 4000)
public void test153() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("&-0Co- h\"-d:XW");
Token token0 = xPathLexer0.nextToken();
assertEquals("&-0Co- h\"-d:XW", token0.getTokenText());
}
/**
//Test case number: 154
/*Coverage entropy=0.7923167011276951
*/
@Test(timeout = 4000)
public void test154() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("%^RiT %2%L9ry`m");
Token token0 = xPathLexer0.notEquals();
assertEquals(22, token0.getTokenType());
assertEquals("%^", token0.getTokenText());
xPathLexer0.colon();
Token token1 = xPathLexer0.colon();
assertEquals(18, token1.getTokenType());
assertEquals("i", token1.getTokenText());
Token token2 = xPathLexer0.dots();
assertEquals(13, token2.getTokenType());
assertEquals("T", token2.getTokenText());
Token token3 = xPathLexer0.nextToken();
assertEquals("%2%L9ry`m", token3.getTokenText());
}
/**
//Test case number: 155
/*Coverage entropy=0.4511636006386335
*/
@Test(timeout = 4000)
public void test155() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("3[$C5It +\"c#`m:[x");
Token token0 = xPathLexer0.doubleColon();
assertEquals("3[", token0.getTokenText());
assertEquals(19, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals("$", token1.getTokenText());
assertEquals(26, token1.getTokenType());
}
/**
//Test case number: 156
/*Coverage entropy=0.3955852454859713
*/
@Test(timeout = 4000)
public void test156() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("#cW");
Token token0 = xPathLexer0.nextToken();
assertEquals("#cW", token0.getTokenText());
}
/**
//Test case number: 157
/*Coverage entropy=0.56217493659866
*/
@Test(timeout = 4000)
public void test157() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("\"6G@hA");
Token token0 = xPathLexer0.nextToken();
assertEquals((-1), token0.getTokenType());
assertEquals("", token0.getTokenText());
}
/**
//Test case number: 158
/*Coverage entropy=1.1757306668170873
*/
@Test(timeout = 4000)
public void test158() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("vIfmZQY.A+V:");
xPathLexer0.setXPath("qJg!Xf$f6OJ8>|p");
Token token0 = xPathLexer0.identifierOrOperatorName();
assertEquals("qJg", token0.getTokenText());
assertEquals(15, token0.getTokenType());
Token token1 = xPathLexer0.nextToken();
assertEquals(23, token1.getTokenType());
assertEquals("!", token1.getTokenText());
Token token2 = xPathLexer0.nextToken();
assertEquals("Xf$f6OJ8>|p", token2.getTokenText());
}
/**
//Test case number: 159
/*Coverage entropy=1.3811482925691614
*/
@Test(timeout = 4000)
public void test159() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("$Zh+LUd d");
Token token0 = xPathLexer0.notEquals();
assertEquals("$", token0.getTokenText());
Token token1 = xPathLexer0.dots();
assertEquals(13, token1.getTokenType());
assertEquals("Z", token1.getTokenText());
Token token2 = xPathLexer0.notEquals();
assertEquals(22, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
Token token4 = xPathLexer0.nextToken();
assertEquals("d", token4.getTokenText());
assertEquals((-1), token4.getTokenType());
}
/**
//Test case number: 160
/*Coverage entropy=1.0986122886681096
*/
@Test(timeout = 4000)
public void test160() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("P<<DXyC4n37b<aY1w");
xPathLexer0.consume(9);
assertEquals("P<<DXyC4n37b<aY1w", xPathLexer0.getXPath());
}
/**
//Test case number: 161
/*Coverage entropy=1.14105741680379
*/
@Test(timeout = 4000)
public void test161() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("S>X9kHvmOaR,4E");
Token token0 = xPathLexer0.minus();
assertEquals("S", token0.getTokenText());
assertEquals(6, token0.getTokenType());
Token token1 = xPathLexer0.colon();
assertEquals(">", token1.getTokenText());
assertEquals(18, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals(15, token2.getTokenType());
assertEquals("X9kHvmOaR", token2.getTokenText());
Token token3 = xPathLexer0.plus();
assertEquals(",", token3.getTokenText());
assertEquals(5, token3.getTokenType());
Token token4 = xPathLexer0.nextToken();
assertEquals("4", token4.getTokenText());
assertEquals(30, token4.getTokenType());
Token token5 = xPathLexer0.doubleColon();
assertEquals(19, token5.getTokenType());
Token token6 = xPathLexer0.nextToken();
assertEquals((-1), token6.getTokenType());
}
/**
//Test case number: 162
/*Coverage entropy=0.9425044392057335
*/
@Test(timeout = 4000)
public void test162() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.rightParen();
assertEquals("c", token0.getTokenText());
assertEquals(2, token0.getTokenType());
Token token1 = xPathLexer0.leftBracket();
assertEquals("o", token1.getTokenText());
assertEquals(3, token1.getTokenType());
Token token2 = xPathLexer0.dots();
assertEquals("m.", token2.getTokenText());
assertEquals(14, token2.getTokenType());
Token token3 = xPathLexer0.nextToken();
assertEquals(15, token3.getTokenType());
assertEquals("werken.saxpath.XPathLexer", token3.getTokenText());
}
/**
//Test case number: 163
/*Coverage entropy=1.0715681822887213
*/
@Test(timeout = 4000)
public void test163() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("com.werken.saxpath.XPathLexer");
Token token0 = xPathLexer0.leftBracket();
assertEquals(3, token0.getTokenType());
assertEquals("c", token0.getTokenText());
Token token1 = xPathLexer0.comma();
assertEquals(32, token1.getTokenType());
assertEquals("o", token1.getTokenText());
Token token2 = xPathLexer0.dots();
assertEquals("m.", token2.getTokenText());
assertEquals(14, token2.getTokenType());
Token token3 = xPathLexer0.whitespace();
assertEquals("", token3.getTokenText());
assertEquals((-2), token3.getTokenType());
Token token4 = xPathLexer0.nextToken();
assertEquals(15, token4.getTokenType());
assertEquals("erken.saxpath.XPathLexer", token4.getTokenText());
}
/**
//Test case number: 164
/*Coverage entropy=1.077585272653389
*/
@Test(timeout = 4000)
public void test164() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("vIfmZQY.A+V:");
Token token0 = xPathLexer0.notEquals();
assertEquals("vI", token0.getTokenText());
xPathLexer0.dots();
xPathLexer0.colon();
Token token1 = xPathLexer0.notEquals();
assertEquals(22, token1.getTokenType());
Token token2 = xPathLexer0.colon();
assertEquals(18, token2.getTokenType());
assertEquals("Q", token2.getTokenText());
Token token3 = xPathLexer0.plus();
assertEquals(5, token3.getTokenType());
assertEquals("Y", token3.getTokenText());
Token token4 = xPathLexer0.nextToken();
assertEquals(13, token4.getTokenType());
assertEquals(".", token4.getTokenText());
Token token5 = xPathLexer0.nextToken();
assertEquals("A+V:", token5.getTokenText());
}
/**
//Test case number: 165
/*Coverage entropy=1.2815377238835206
*/
@Test(timeout = 4000)
public void test165() throws Throwable {
XPathLexer xPathLexer0 = new XPathLexer("2~.mkbdWk06!1o");
Token token0 = xPathLexer0.nextToken();
assertEquals(30, token0.getTokenType());
assertEquals("2", token0.getTokenText());
Token token1 = xPathLexer0.dots();
assertEquals("~.", token1.getTokenText());
assertEquals(14, token1.getTokenType());
Token token2 = xPathLexer0.nextToken();
assertEquals("mkbdWk06!1o", token2.getTokenText());
}
}
| 30.050576 | 176 | 0.644123 |
3dc907bfadfb9b5495e84b6ac19d8602106c9ea1 | 3,634 | package com.softicar.platform.emf.action;
import com.softicar.platform.common.core.user.CurrentBasicUser;
import com.softicar.platform.common.core.user.IBasicUser;
import com.softicar.platform.dom.element.DomElementTag;
import com.softicar.platform.dom.elements.DomDiv;
import com.softicar.platform.dom.elements.DomElementsImages;
import com.softicar.platform.dom.elements.button.DomButton;
import com.softicar.platform.emf.EmfI18n;
import com.softicar.platform.emf.action.marker.EmfCommonActionMarker;
import com.softicar.platform.emf.form.IEmfFormBody;
import com.softicar.platform.emf.form.section.EmfFormSectionDiv;
import com.softicar.platform.emf.form.section.header.EmfFormSectionHeader;
import com.softicar.platform.emf.permission.EmfAnyPermission;
import com.softicar.platform.emf.permission.IEmfPermission;
import com.softicar.platform.emf.predicate.EmfPredicates;
import com.softicar.platform.emf.predicate.IEmfPredicate;
import com.softicar.platform.emf.table.row.IEmfTableRow;
import java.util.ArrayList;
import java.util.Collection;
import java.util.stream.Collectors;
public abstract class AbstractEmfAggregatingAction<R extends IEmfTableRow<R, ?>> implements IEmfCommonAction<R> {
private final Collection<IEmfPrimaryAction<R>> actions;
public AbstractEmfAggregatingAction() {
this.actions = new ArrayList<>();
}
@Override
public final void handleClick(IEmfFormBody<R> formBody) {
formBody.showSectionContainer(new ActionDiv<>(this, formBody));
}
@Override
public IEmfPredicate<R> getPrecondition() {
IEmfPredicate<R> predicate = EmfPredicates.never();
for (IEmfPrimaryAction<R> action: actions) {
predicate = predicate.or(action.getPrecondition());
}
return predicate;
}
@Override
public IEmfPermission<R> getRequiredPermission() {
return new EmfAnyPermission<>(
actions//
.stream()
.map(action -> action.getRequiredPermission())
.collect(Collectors.toList()));
}
@Override
public final boolean isAvailable(R tableRow, IBasicUser user) {
return actions//
.stream()
.anyMatch(action -> action.isAvailable(tableRow, user));
}
public Collection<IEmfPrimaryAction<R>> getActions() {
return actions;
}
protected void addAction(IEmfPrimaryAction<R> action) {
actions.add(action);
}
private static class ActionDiv<R extends IEmfTableRow<R, ?>> extends EmfFormSectionDiv<R> {
private final IEmfFormBody<R> formBody;
public ActionDiv(AbstractEmfAggregatingAction<R> action, IEmfFormBody<R> formBody) {
super(formBody, new SectionHeader<>(action));
this.formBody = formBody;
integrateActions(action.getActions(), formBody);
addMarker(new EmfCommonActionMarker(action));
addElement(CancelDiv::new);
setOpen(true);
}
private void integrateActions(Collection<IEmfPrimaryAction<R>> actions, IEmfFormBody<R> formBody) {
R tableRow = formBody.getTableRow();
IBasicUser user = CurrentBasicUser.get();
for (IEmfPrimaryAction<R> action: actions) {
if (action.isAvailable(tableRow, user)) {
action.integrate(tableRow, this);
}
}
}
private class CancelDiv extends DomDiv {
public CancelDiv() {
appendNewChild(DomElementTag.HR);
appendChild(
new DomButton()//
.setIcon(DomElementsImages.DIALOG_CANCEL.getResource())
.setLabel(EmfI18n.CANCEL)
.setClickCallback(() -> formBody.showStandardSectionContainer()));
}
}
}
private static class SectionHeader<R extends IEmfTableRow<R, ?>> extends EmfFormSectionHeader {
public SectionHeader(AbstractEmfAggregatingAction<R> action) {
setIcon(action.getIcon()).setCaption(action.getTitle());
}
}
}
| 28.390625 | 113 | 0.762796 |
4b4a4929fe62f43d3c63b7ea4430009ec25dbb99 | 1,746 | package com.nothing.mark.popmoviesapp.Database;
import android.content.ContentResolver;
import android.net.Uri;
import android.provider.BaseColumns;
public class MoviesContract {
public interface MoviesColumns {
String MOVIE_ID = "movie_id";
String MOVIE_TITLE = "title";
String MOVIE_OVERVIEW = "overview";
String MOVIE_RELEASE_DATE = "release_date";
String MOVIE_POSTER_PATH = "poster_path";
String MOVIE_BACKDROP_PATH = "backdrop_path";
String MOVIE_POPULARITY = "popularity";
String MOVIE_VOTE_AVERAGE = "vote_average";
String MOVIE_VOTE_COUNT = "vote_count";
String MOVIE_FAVORITE = "favorite";
}
public static final String CONTENT_AUTHORITY = "com.nothing.mark.popmoviesapp.provider";
public static final Uri BASE_CONTENT_URI = Uri.parse("content://" + CONTENT_AUTHORITY);
public static final String PATH_MOVIES = "movies";
public static class Movies implements MoviesColumns, BaseColumns {
public static final Uri CONTENT_URI = BASE_CONTENT_URI.buildUpon().appendPath(PATH_MOVIES).build();
public static final String SORT_ORDER = BaseColumns._ID + " DESC";
public static final String CONTENT_TYPE = ContentResolver.CURSOR_DIR_BASE_TYPE + "/" + CONTENT_AUTHORITY + "/" + PATH_MOVIES;
public static final String CONTENT_ITEM_TYPE = ContentResolver.ANY_CURSOR_ITEM_TYPE + "/" + CONTENT_AUTHORITY + "/" + PATH_MOVIES;
public static Uri buildUri(String movieId) {
return CONTENT_URI.buildUpon().appendPath(movieId).build();
}
public static String getId(Uri uri) {
return uri.getPathSegments().get(1);
}
}
private MoviesContract() {}
}
| 39.681818 | 138 | 0.700458 |
c6280870f448ebe98939410ff65d9e3131594514 | 2,916 | package duckutil.gatecontrol;
import duckutil.jsonrpc.JsonRpcServer;
import duckutil.Config;
import com.thetransactioncompany.jsonrpc2.JSONRPC2Request;
import com.thetransactioncompany.jsonrpc2.JSONRPC2Response;
import com.thetransactioncompany.jsonrpc2.server.Dispatcher;
import com.thetransactioncompany.jsonrpc2.server.MessageContext;
import com.thetransactioncompany.jsonrpc2.server.RequestHandler;
import duckutil.jsonrpc.JsonRequestHandler;
import net.minidev.json.JSONObject;
import net.minidev.json.JSONArray;
import java.util.Map;
public class RpcServer
{
private final JsonRpcServer json_rpc_server;
private final RelayControl relay_control;
public RpcServer(Config config, RelayControl relay_control)
throws Exception
{
this.relay_control = relay_control;
json_rpc_server = new JsonRpcServer(config, true);
json_rpc_server.register(new OpenHandler());
json_rpc_server.register(new ListHandler());
json_rpc_server.register(new CloseHandler());
}
public class OpenHandler extends JsonRequestHandler
{
public String[] handledRequests()
{
return new String[]{"open"};
}
protected JSONObject processRequest(JSONRPC2Request req, MessageContext ctx)
throws Exception
{
String id = req.getID().toString();
Object time_obj = req.getNamedParams().get("time");
long time_ms=5000;
if (time_obj instanceof Number)
{
Number n = (Number) time_obj;
time_ms = n.longValue();
}
relay_control.connectRelay("rpc_" + id, time_ms);
JSONObject reply = new JSONObject();
reply.put("time", time_ms);
return reply;
}
}
public class ListHandler extends JsonRequestHandler
{
public String[] handledRequests()
{
return new String[]{"list"};
}
protected JSONObject processRequest(JSONRPC2Request req, MessageContext ctx)
throws Exception
{
String id = req.getID().toString();
JSONObject reply = new JSONObject();
JSONArray holds_json = new JSONArray();
for(Map.Entry<String, Long> me : relay_control.getHolds().entrySet())
{
JSONObject h = new JSONObject();
h.put("id", me.getKey());
h.put("expire", me.getValue());
long ttl = me.getValue() - System.currentTimeMillis();
h.put("ttl",ttl);
holds_json.add(h);
}
reply.put("holds", holds_json);
return reply;
}
}
public class CloseHandler extends JsonRequestHandler
{
public String[] handledRequests()
{
return new String[]{"close"};
}
protected JSONObject processRequest(JSONRPC2Request req, MessageContext ctx)
throws Exception
{
String id = req.getID().toString();
JSONObject reply = new JSONObject();
relay_control.close();
return reply;
}
}
}
| 21.6 | 80 | 0.671468 |
f6a667308907896db1054518309af018c634799d | 3,346 | /*
* Copyright (c) 2018 AITIA International Inc.
*
* This work is part of the Productive 4.0 innovation project, which receives grants from the
* European Commissions H2020 research and innovation programme, ECSEL Joint Undertaking
* (project no. 737459), the free state of Saxony, the German Federal Ministry of Education and
* national funding authorities from involved countries.
*/
package eu.arrowhead.core.systemregistry;
import eu.arrowhead.core.systemregistry.model.AHSystem;
import java.util.List;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.GenericEntity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import org.apache.log4j.Logger;
@Path("systemregistry")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class SystemRegistryResource {
private static final Logger log = Logger.getLogger(SystemRegistryResource.class.getName());
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getIt() {
return "This is the System Registry Arrowhead Core System.";
}
@GET
@Path("lookup")
public Response Lookup(@QueryParam("id") String id) throws Exception {
//SystemRegistryHAAASALMySql sr = new SystemRegistryHAAASALMySql();
SystemRegistryService srs = new SystemRegistryService();
List<AHSystem> systems = srs.Lookup(id);
GenericEntity entity = new GenericEntity<List<AHSystem>>(systems) {
};
return Response.status(200).entity(entity).build();
}
@POST
@Path("publish")
public Response Publish(@QueryParam("id") String id) throws Exception {
Status status = null;
String message = "";
if (id == null) {
return Response.status(400).entity("Please provide an ID!").build();
}
//SystemRegistryHAAASALMySql sr = new SystemRegistryHAAASALMySql();
SystemRegistryService srs = new SystemRegistryService();
status = srs.Publish(id);
switch (status) {
case CREATED:
// system was successfully published
message = "The System with the ID: '" + id + "' has been successfully published!";
break;
case CONFLICT:
// ID already exists
message = "The System-ID: '" + id
+ "' has already been published! Please unpublish the system and try publishing it again!";
break;
default:
message = "";
break;
}
return Response.status(status).entity(message).build();
}
@POST
@Path("unpublish")
public Response Unpublish(@QueryParam("id") String id) throws Exception {
Status status = null;
String message = "";
if (id == null) {
return Response.status(400).entity("Please provide an ID!").build();
}
//SystemRegistryHAAASALMySql sr = new SystemRegistryHAAASALMySql();
SystemRegistryService srs = new SystemRegistryService();
status = srs.Unpublish(id);
switch (status) {
case OK:
// system was successfully unpublished
message = "The System with the ID: '" + id + "' has been successfully unpublished!";
break;
case NOT_FOUND:
// ID already exists
message = "The System-ID: '" + id + "' could not be found in the SystemRegistry! System does not exist!";
break;
default:
message = "";
break;
}
return Response.status(status).entity(message).build();
}
} | 29.095652 | 108 | 0.720861 |
364efb47171423b79dcb56bfd0b81e761993339e | 269 | package de.adorsys.sts.keymanagement.service;
import de.adorsys.keymanagement.api.types.template.provided.ProvidedKey;
import java.util.function.Supplier;
public interface SecretKeyGenerator {
ProvidedKey generate(String alias, Supplier<char[]> keyPassword);
}
| 24.454545 | 72 | 0.810409 |
2c2cfbfd183c03d026224c4b983bb2513c46827d | 2,448 | package cmps252.HW4_2.UnitTesting;
import static org.junit.jupiter.api.Assertions.*;
import java.io.FileNotFoundException;
import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import cmps252.HW4_2.Customer;
import cmps252.HW4_2.FileParser;
@Tag("14")
class Record_4703 {
private static List<Customer> customers;
@BeforeAll
public static void init() throws FileNotFoundException {
customers = FileParser.getCustomers(Configuration.CSV_File);
}
@Test
@DisplayName("Record 4703: FirstName is Stephanie")
void FirstNameOfRecord4703() {
assertEquals("Stephanie", customers.get(4702).getFirstName());
}
@Test
@DisplayName("Record 4703: LastName is Rashdi")
void LastNameOfRecord4703() {
assertEquals("Rashdi", customers.get(4702).getLastName());
}
@Test
@DisplayName("Record 4703: Company is Carl Budding & Co")
void CompanyOfRecord4703() {
assertEquals("Carl Budding & Co", customers.get(4702).getCompany());
}
@Test
@DisplayName("Record 4703: Address is 4125 N 14th St")
void AddressOfRecord4703() {
assertEquals("4125 N 14th St", customers.get(4702).getAddress());
}
@Test
@DisplayName("Record 4703: City is Phoenix")
void CityOfRecord4703() {
assertEquals("Phoenix", customers.get(4702).getCity());
}
@Test
@DisplayName("Record 4703: County is Maricopa")
void CountyOfRecord4703() {
assertEquals("Maricopa", customers.get(4702).getCounty());
}
@Test
@DisplayName("Record 4703: State is AZ")
void StateOfRecord4703() {
assertEquals("AZ", customers.get(4702).getState());
}
@Test
@DisplayName("Record 4703: ZIP is 85014")
void ZIPOfRecord4703() {
assertEquals("85014", customers.get(4702).getZIP());
}
@Test
@DisplayName("Record 4703: Phone is 602-241-7013")
void PhoneOfRecord4703() {
assertEquals("602-241-7013", customers.get(4702).getPhone());
}
@Test
@DisplayName("Record 4703: Fax is 602-241-2282")
void FaxOfRecord4703() {
assertEquals("602-241-2282", customers.get(4702).getFax());
}
@Test
@DisplayName("Record 4703: Email is stephanie@rashdi.com")
void EmailOfRecord4703() {
assertEquals("stephanie@rashdi.com", customers.get(4702).getEmail());
}
@Test
@DisplayName("Record 4703: Web is http://www.stephanierashdi.com")
void WebOfRecord4703() {
assertEquals("http://www.stephanierashdi.com", customers.get(4702).getWeb());
}
}
| 25.5 | 79 | 0.732026 |
411ce4613db42b56a64e017135e31a1e0737734c | 3,114 | /**
* easyWSDL - easyWSDL toolbox Platform.
* Copyright (c) 2008, eBM Websourcing
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the University of California, Berkeley nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.ow2.easywsdl.wsdl.api.abstractElmt;
import java.util.ArrayList;
import java.util.List;
import org.ow2.easywsdl.wsdl.api.abstractItf.AbsItfDescription;
import org.ow2.easywsdl.wsdl.api.abstractItf.AbsItfEndpoint;
import org.ow2.easywsdl.wsdl.api.abstractItf.AbsItfInterfaceType;
import org.ow2.easywsdl.wsdl.api.abstractItf.AbsItfOperation;
import org.ow2.easywsdl.wsdl.api.abstractItf.AbsItfService;
/**
* @author Nicolas Salatge - eBM WebSourcing
*/
@SuppressWarnings("unchecked")
public abstract class AbstractServiceImpl<E, I extends AbsItfInterfaceType<? extends AbsItfOperation>, Ep extends AbsItfEndpoint>
extends AbstractWSDLElementImpl<E> implements AbsItfService<I, Ep> {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* the desc
*/
protected AbsItfDescription desc;
/**
* list of endpoints
*/
protected List<Ep> endpoints = new ArrayList<Ep>();
public AbstractServiceImpl(E model, AbstractWSDLElementImpl parent) {
super(model, parent);
}
public void addEndpoint(final Ep endpoint) {
this.endpoints.add(endpoint);
}
public Ep getEndpoint(final String name) {
Ep res = null;
for (final Ep ep : this.endpoints) {
if (ep.getName() != null && ep.getName().equals(name)) {
res = ep;
break;
}
}
return res;
}
public List<Ep> getEndpoints() {
return this.endpoints;
}
/**
* @return the desc
*/
public AbsItfDescription getDescription() {
return this.desc;
}
}
| 33.847826 | 129 | 0.742453 |
cb933b3e312454683920d3ca2fb2f21310348946 | 314 | package ru.job4j.search;
import java.util.Comparator;
public class AllFieldsComparator implements Comparator<User> {
@Override
public int compare(User o1, User o2) {
final int name = o1.getName().compareTo(o2.getName());
return name != 0 ? name : o1.getAge().compareTo(o2.getAge());
}
} | 34.888889 | 69 | 0.678344 |
3698d2b37a5958c446909894330952ccb9d40583 | 232 | package com.slimgears.sample;
import com.google.common.collect.ImmutableList;
import com.slimgears.util.autovalue.annotations.AutoValuePrototype;
@AutoValuePrototype
public interface SampleList<T> {
ImmutableList<T> list();
}
| 23.2 | 67 | 0.810345 |
3e0af1b6fe8287f83b4f5e44709c8cbe0418dc48 | 2,412 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.dubbo.common.threadlocal.concurrent;
import org.apache.dubbo.common.threadpool.concurrent.ScheduledCompletableFuture;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;
public class ScheduledCompletableFutureTest {
@Test
public void testSubmit() throws Exception {
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
CompletableFuture<String> futureOK = ScheduledCompletableFuture.submit(executorService, () -> "done");
Assertions.assertEquals(futureOK.get(), "done");
CompletableFuture<Integer> futureFail = ScheduledCompletableFuture.submit(executorService, () -> 1 / 0);
Assertions.assertThrows(ExecutionException.class, () -> futureFail.get());
}
@Test
public void testSchedule() throws Exception {
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
CompletableFuture<String> futureOK = ScheduledCompletableFuture.schedule(executorService, () -> "done", 1000, TimeUnit.MILLISECONDS);
Assertions.assertEquals(futureOK.get(), "done");
CompletableFuture<Integer> futureFail = ScheduledCompletableFuture.schedule(executorService, () -> 1 / 0, 1000, TimeUnit.MILLISECONDS);
Assertions.assertThrows(ExecutionException.class, () -> futureFail.get());
}
} | 45.509434 | 143 | 0.762023 |
690fbb89e640f94c37f25bc4e8f614563ced1b8f | 5,636 | package com.example.administrator.shoppingcartproject;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Looper;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.TextView;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
public class MainActivity extends AppCompatActivity implements View.OnClickListener,CheckInterface,ModifyCountInterface{
private List<GoodsInfo> goodsInfoList=new ArrayList<>();
String TAG="ShoppingCart";
private GoodsAdapter goodsAdapter;
private CheckBox ckAll;
private TextView calc_all;
private Button btn_count;
private ModifyCountInterface modifyCountInterface;
private int totalPrice=0;//购买商品总价
private int totalCount=0;//购买商品总数
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn_count=findViewById(R.id.btn_count);
calc_all=findViewById(R.id.calc_all);
ckAll=findViewById(R.id.check_all);
ckAll.setOnClickListener(this);
initGoodsInfo();
RecyclerView recyclerView=findViewById(R.id.recycler_view);
LinearLayoutManager layoutManager=new LinearLayoutManager(this);
recyclerView.setLayoutManager(layoutManager);
goodsAdapter=new GoodsAdapter(goodsInfoList);
recyclerView.setAdapter(goodsAdapter);
goodsAdapter.setModifyCountInterface(this);
goodsAdapter.setCheckInterface(this);
}
private void initGoodsInfo(){
for(int i=0;i<1;i++){
GoodsInfo goodsInfo1=new GoodsInfo(false,R.drawable.img01,
"荣耀20青春版 AMOLED屏幕指纹 4000mAh大电池 20W快充 4800万 手机 4GB+64GB 冰岛幻境",999,1);
goodsInfoList.add(goodsInfo1);
GoodsInfo goodsInfo2=new GoodsInfo(false,R.drawable.img02,
"华为 HUAWEI Mate 30 5G 麒麟990 4000万超感光徕卡影像双超级快充8GB+128GB亮黑色5G全网通游戏手机",4499,1);
goodsInfoList.add(goodsInfo2);
GoodsInfo goodsInfo3=new GoodsInfo(false,R.drawable.img03,
"小米10 Pro 双模5G 骁龙865 1亿像素8K电影相机 50倍变焦 50W快充 12GB+512GB 珍珠白 拍照智能新品游戏手机",5999,1);
goodsInfoList.add(goodsInfo3);
GoodsInfo goodsInfo4=new GoodsInfo(false,R.drawable.img04,
"Apple iPhone XS Max (A2104) 256GB 银色 移动联通电信4G手机 双卡双待",7299,1);
goodsInfoList.add(goodsInfo4);
}
}
@Override
public void onClick(View view) {
switch (view.getId()){
case R.id.check_all:
// Toast.makeText(MainActivity.this,"点击全选",Toast.LENGTH_SHORT).show();
if (goodsInfoList.size()!=0){
if(ckAll.isChecked()){
for(int i=0;i<goodsInfoList.size();i++){
goodsInfoList.get(i).setSelect_state(true);
}
goodsAdapter.notifyDataSetChanged();
}else {
for (int i=0;i<goodsInfoList.size();i++){
goodsInfoList.get(i).setSelect_state(false);
}
goodsAdapter.notifyDataSetChanged();
}
}
statistics();
break;
default:
break;
}
}
//统计
private void statistics() {
totalCount=0;
totalPrice=0;
for(int i=0;i<goodsInfoList.size();i++){
GoodsInfo goodsInfo=goodsInfoList.get(i);
if(goodsInfo.isSelect_state()){
totalCount+=goodsInfo.getNum();
totalPrice+=goodsInfo.getPrice() * goodsInfo.getNum();
}
}
calc_all.setText("合计：¥"+totalPrice);
btn_count.setText("去结算（"+totalCount+"）");
}
@Override
public void checkGroup(int position, boolean isChecked) {
goodsInfoList.get(position).setSelect_state(isChecked);
if (isAllCheck())
ckAll.setChecked(true);
else
ckAll.setChecked(false);
goodsAdapter.notifyDataSetChanged();
statistics();
}
//遍历集合
private boolean isAllCheck() {
for (GoodsInfo goodsInfo:goodsInfoList){
if(!goodsInfo.isSelect_state())
return false;
}
return true;
}
@Override
public void doIncrease(int position, View showCountView, boolean isChecked) {
GoodsInfo goodsInfo=goodsInfoList.get(position);
int goodsNum=goodsInfo.getNum();
goodsNum++;
goodsInfo.setNum(goodsNum);
((TextView)showCountView).setText(goodsNum+"");
goodsAdapter.notifyDataSetChanged();
statistics();
}
@Override
public void doDecrease(int position, View showCountView, boolean isChecked) {
GoodsInfo goodsInfo=goodsInfoList.get(position);
int currentCount=goodsInfo.getNum();
currentCount--;
goodsInfo.setNum(currentCount);
((TextView)showCountView).setText(currentCount+"");
goodsAdapter.notifyDataSetChanged();
statistics();
}
@Override
public void childDelete(int position) {
goodsInfoList.remove(position);
goodsAdapter.notifyDataSetChanged();
statistics();
}
}
| 33.748503 | 120 | 0.633605 |
232333f4c1981343fd1a3ba96ef0402a10abf13b | 904 | package com.tepidpond.tum;
import com.tepidpond.tum.PlateTectonics.Lithosphere;
public class G {
public static final String ModID = "TUM";
public static final String ModName = "The Unknown Mod";
// see http://en.wikipedia.org/wiki/Linear_congruential_generator
public static final long LCG_Mult_A = 6364136223846793005L;
public static final long LCG_Inc_C = 1442695040888963407L;
public class WorldGen {
public static final int DefaultMapSize = 512;
public static final float DefaultLandSeaRatio = 0.65f;
public static final int DefaultErosionPeriod = 60;
public static final float DefaultFoldingRatio = 0.001f;
public static final int DefaultAggrRatioAbs = 5000;
public static final float DefaultAggrRatioRel = 0.1f;
public static final int DefaultMaxCycles = 2;
public static final int DefaultNumPlates = 10;
public static final int DefaultMaxGens = 600;
}
}
| 36.16 | 66 | 0.771018 |
c0c68688f31f4b03978031e0afd13a0be55117c7 | 2,769 | package com.example.soc.find;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.graphics.Color;
import android.os.Bundle;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.example.soc.R;
import com.example.soc.func.BackPressHandler;
//Activity를 상속받으면 앱바가 없음
public class FindActivity extends Activity {
// UI references.
private BackPressHandler backPressHandler = new BackPressHandler(this);
InputMethodManager imm;
LinearLayout ll;
Button findSend, checkNext;
TextView sendcheck, tfcheck;
EditText schoolnum, email, checnum;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_find);
imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
findSend = (Button) findViewById(R.id.findsend);
checkNext = (Button) findViewById(R.id.checknext);
sendcheck = (TextView) findViewById(R.id.sendcheck);
tfcheck = (TextView) findViewById(R.id.tfcheck);
findSend.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view){
sendcheck.setText("인증번호가 발송되었습니다.");
}
});
checkNext.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view){
Intent intent = new Intent(getApplicationContext(), InFindActivity.class);
startActivity(intent);
}
});
//화면클릭 시 키보드 숨김
LinearLayout ll = (LinearLayout) findViewById(R.id.ll);
ll.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
});
}
public void showDialog() {
AlertDialog.Builder msgBuilder = new AlertDialog.Builder(com.example.soc.find.FindActivity.this)
.setTitle("알림")
.setMessage("인증번호가 일치하지 않습니다.")
.setPositiveButton("확인",null);
AlertDialog msgDlg = msgBuilder.create();
msgDlg.show();
}
}
| 36.92 | 113 | 0.61719 |
8b42f6be45aaf95e36737887f042ac6dc46cac10 | 22,239 | class MXtcBhizeE0 {
public void UB;
public void bbP_AzMgZjzA6;
public static void NfLwo17GwvOQ_ (String[] POBEwwbrpC5) throws F {
!!new z20VB17EKA1Qj[ ZiqiJV_xhDV3sn.DkPQGyVCWiex()].fqReR();
L0ZFmNmCT[] ICmlEdF = true[ ---!-!!new eI()[ !-true.rJwf1QZ2uDVip()]];
int[][][] sQ0SddIB4;
void fxcDl;
void ugJCJt;
while ( -454.SUuswEUxnSoBb()) {
CRf PZfbb6jdEIOESk;
}
boolean Ea = ( new nTAJ1().x4bvic()).R;
}
public boolean[] wLCN7b9HD;
public bE4hq3U PrQ9pCo47W3 () {
{
{
{
{
void[][] KTaGMkB;
}
}
}
Ti[][][][][] LW3qFTu1hW7nm;
;
while ( -new r8QWZsuCsk7().LVJ5IBvgu()) if ( --new int[ -!!null.mGSOeRi()].EgFQpAsOCp) {
!r.yqBipC7Lt3LC;
}
boolean[][] qw8SaJw4FfeV;
return;
;
BHfP[][] d09U4ZLnU;
return;
;
while ( !nooef2xP.RoPruCJD0) ;
( false.x_())[ LqoX5ghtmx6QwE().dE5u1vpv0p9Cn];
}
;
if ( HtC().fmTLcq6qlbQVnD) ;
return -3789[ -new rX8YX().rY_2q()];
Rm9oDDLv9 gkVa4CmrQ;
void[] UvCs2baH7qFyWl;
{
;
boolean[] yItGsyeMUW;
false.x();
boolean nzjB0;
( -!--JE1().ZRzQKPYh1iE())[ true[ !JNMSM9e_()[ ( !!true[ THE5ejK31oe.EYFni]).FePXRx2()]]];
boolean[][][][][][] o;
boolean[][][][] ky_qWJoMo_7f;
if ( -new boolean[ new k_ENm()[ --true[ new boolean[ !-new PrHQfda().gx6fQadWr5ER].bq]]].jhWBRCa()) {
return;
}
rAM Gon0z_j6nTQQ;
joQl_NT[] _JEG2n1r9ZEiH;
int[] UOKGG6Zy_GeTW;
int[][] yO;
boolean[] f7rt;
void[][][] ss62Ty2U4ex;
}
int[][][] GLL7;
{
{
if ( false.E08jay9CyKI()) new int[ ( -null.ELL7qN).yVGNHuRKuwl()].KwaVoVWra;
}
int[] aREgh7n_WaroM;
int do1gnp;
if ( false[ -new kApjbitCL().YLy51()]) return;
RkEQPY yEQ5vEbicCbJt;
void[][] R7gXc;
boolean Zr;
void L6N1XGpIVSzCL;
{
if ( xVEKEUd.liW9msWx5PzwbR()) ;
}
if ( this.onoPBswdqOQMD()) while ( !this[ -!this.j0WWo8RcJjKkZ()]) {
while ( wceJinHqodh9uF.R6CEKEzDejY) if ( new qrHmzp2HKTbD().RVKbtCjM) while ( new boolean[ null.F7ApuRo9Pgagk].WhkIXl()) return;
}
boolean SYul;
while ( !!-new boolean[ new sabS().QAyl63C2rEh()].X2YugW()) while ( false.glNwFFYigZ_()) if ( -( -true.WgD85vib)[ new Bf()[ !!true[ !-this.E30y_hZ()]]]) if ( ( !-goRSICrH3[ M8I7Zh2[ false[ !new H04s[ -!!new v3TIDXD()[ -false.cTNI]][ true.lvp()]]]])[ 243789340.XHZmoWe()]) ;
;
if ( --new void[ null[ 758565.dEJU2t]][ false.JNTo4()]) return;
}
int f = 375293459.ATr();
{
if ( zdbi6D[ -!!!--cWqSYydMlBNgpB[ -!!QmYovX4Y3K.A6BaJRz9PCaO()]]) ;
boolean S1kR_GoPw5RiP;
int NTnDR;
while ( CpTy()[ new slgZQJGYUEeTk[ ( -null[ true.iPRDo0GXUibwB()])[ !null.CK43HA()]]._OXkgFyq()]) return;
{
int[][] pGUoYlov;
}
OD5PrW[][][][][][][] hdzGHk46d;
return;
int[][][] kxltiME;
;
int[] r;
while ( new int[ -!new void[ false[ -false.TZjqu()]].QCCsreSroPPUXk].yM()) ;
{
!-false.MMD7n();
}
if ( true.DUC4pm()) if ( -null.zjw()) {
!new void[ -false.UXOhe()][ -new V9MzrBOSP().lC2G0N0v9s()];
}
void[][] UmqT3wz0a;
if ( -( --B9jiKOiT().JxNB).W4oLjubs) ;
}
}
public static void J5a (String[] tU4mCZcZH2e2m) {
int _WWZ;
while ( -!!-new JHcMyc().BoO_DQPVfusz) ;
rr52pNB5().xahLO549u2rRl();
int[] zB;
void[] p;
int[] Za47NRWnTH = -new void[ -R0cp0fbxIBqXZ().d6FOxVXl5LrZRW][ new boolean[ --!!this.tN3W()][ !-!P().O5pQ5R3sFJQc4()]];
return new F10otQ2v().s6Y83U8;
iA_S4e109[] lCmyDW3 = new EX53tv().wPP();
boolean[][][][] CjbAs = new i5jxLYc_puw()[ true[ this.kINYE5w7W()]] = -null.vBvBqMSRoIckI();
int XXcppq;
;
RRvgSV[][] UphXoeF2iMAi6 = !!new void[ xMPD().T1QR].K_OtrDod();
while ( false.nOhMucr54p2) ;
{
boolean qvgrVi2_477;
GxHFH9eZcCJV[] ZB2Ut6kq_s3TpM;
return;
int[][][][][][] _OVXzHaqU_O;
boolean[] S;
return;
vq7sL7qciI2wy[][] Rv7f;
int U;
;
while ( -!new dh4[ VloHT6If().Lak8E()][ --true[ r8.BqJ]]) return;
if ( E1f2k2nnLLtVv().N()) !new HEC7Xjtv()[ RXuc9yTeIGEATS.sr0EMvaR];
return;
ID6dLKuh m5KHkB8drmZ;
boolean[][][] a9BeHdWMJrLE6A;
int[][] XGwK9Rxj08l;
void npAUS5e;
B W3e;
HeExvtgqibGy HU;
;
}
CXRyEEAZe[][][][][][] ep = 2338[ fmieYYgs()[ new GkJYMBHDqp7Tz().VeGkgtzY()]] = false.Yyp338hIJ();
}
public static void o0 (String[] ubQFOrMKfB3) {
void[] GoKN30 = !-!null.BwcfK;
void[] J1P3PkDle8UH;
;
while ( new F[ false[ new rMsXWB3yeUInA().COntcsqqZLY0t()]].PRIz()) return;
int[] rJA;
;
while ( -null[ ( --this.jPUaSS0)[ null.YJOd7fx5()]]) if ( ( new ipP4mrQbpO()._o1qeF)[ EA().bVkEb1y]) return;
int fEVG;
while ( ( !-!-new l5BdqhzdPoit[ !true.MhrWHT0rL4U].iTY6BL)[ -!RI().TAV3Amth]) if ( -false.o) return;
void QF = --!-!snKo8X().ZWusOpR08vNi1S = JZ6mctZl.rWCgJcwTijqLj();
boolean[][] hr;
if ( -new a4JF01UbYYxe[ VMKc[ OazHB_hb6lT()[ null[ !new Eaf62Y5Xi()[ new RtuGEGrTGNRz()[ null.p5ezS14pgoyoy]]]]]][ -new VJZG6vuBafN[ !t_JXcm[ Dd9a.y]][ -new ZNc3xYEsmgbUEb()[ true[ !null.dSJgwXrtcii()]]]]) {
DcD[] AM17GxcAV7;
}
return new void[ !!true.iNZ].Fnt3M_3;
int wCzbPx_;
}
public void RK;
public static void IIIZKmZ (String[] uY_h) throws LzZSzXW4jtHZ1X {
void[] I3j;
nuJ PQAh = !-!zA8kw.My6IfjKN = !!!!-!!SdGFO5k().ERK();
this[ new WtEMV().J9nhC2NDISufrD];
yfu M5HUBMJ_Ut3XI = new zESdXYJqiYrcA().kRM();
Im1BYj_pzxa[][][][] V1 = -65271300.vWiyWt = --!!!-Zu2L_i().zHb();
int[][][][] c41GBtujp0 = -!-false.IF0z3ww;
return;
;
int OfXPsH = !z[ CxH2()[ !!!this.R27V()]] = !!!!f0E4Ka().u7AkoxL();
int[] X7buUjK;
if ( --!false.vJ7Hvyk29g) 9.jabfByDO_;else return;
-!!-( new Xm().zc056H0ANusH()).nxlJYELqF;
}
public static void hOW (String[] i) throws iO8YmUr {
DbdN[] zxAc9U81k15xqq = !-new ZH2rIHqS().yr = 0709[ new void[ S0X4Z.FEUP_lBH4B1iw].kvQ3Otudg];
void[] J81h6jNDl = ---SnQnmQ9I2s.A3cv2;
TvbkvFXHdgtLD[][] d4cUD;
while ( --false[ new boolean[ ( true.sH()).O_u].Ei8k()]) return;
return;
HPRUj9wa[] r_6z0UXd4mKL;
int[] _oG21RvF;
-new Ey0yj0GpA().uVUzcHQcN;
!true.XQy8EEQ;
;
--EazeBgposd_()[ false.c8()];
;
int XL95W8VL;
int[] NQYY8nnpwsAm;
if ( --!new void[ z06uuxkPQuE().Ec].zDiYxO) ;
uOhjPjOgWM5L[] A2Ivj;
return !-new XsSuF().rKvjLXEKNr3M;
return new rhmoXv9aF().My1u5Q4vL;
}
public boolean UIx7rA80akaDr;
public void[][] TO () {
I URAJt6sCE9ETz;
void f9cddN;
int[][] M_eN;
boolean zsPV;
new AWrvj7H0H().tjf5U();
while ( true.ryuQzEVI()) if ( null[ Oe[ !new xP[ !this[ this.P8w4g8CYiB()]].n8hrmHRXF_2uaL]]) if ( -new boolean[ !-( !this.KZaC1()).oGBZT][ -57013632[ true.Wrxa6C7nJTzAV0]]) return;
void[] isWLm = !63974.K5ehyKVrOGdA;
boolean[] T6W8_u;
return this.WU8;
int[] n9qDq = 925.dhnhAG9MlNM0;
while ( true.mQgiqrmZjDza()) return;
QZy6KIll2N8l_[] Ewz6BXZGU = go87t6aRNi()[ this.XmqYqpPzMl()] = this.ub_jhlxY2;
}
public void lcWKYWgQIzm18N;
}
class Z_0 {
}
class NP59 {
public static void ZuVRg1s1pwM (String[] M) {
void H5fj5I2zR;
;
yLc Mu9d = !this.aqCrlk() = -!!( !oTlqPAq8M.X9Vu1QdGDm()).n6U3();
boolean[] XxM_amtgTxHlq;
int[][][][][][][][][][][] PAb2;
CnWtoFd[][] _ZP8tY;
if ( ---zvk().pKIlF6l7KGTKjz()) return;else ;
if ( JOP.Bll()) {
boolean[][][] wsOM;
}
;
boolean tGM5b = -!--new gVZfmp().XXeOMu5AEY;
int KH2kFv1iFy = -false.euMKSLYMTX_ = !!!ApdlBCqOTwE().HNTlNpZ;
boolean[][][] FNxVEZ8fAcqcy = new int[ new void[ !null.zHqz()].zQVz].nv3fyWwvOnVZgO;
}
public boolean H;
public static void _jjRFQopam (String[] ZiX) throws fjjoZ2GeJk_un8 {
void L1;
return;
return -!new atmy().cS0A();
if ( this.w3rERP()) if ( !!( ( JBPyGFH()[ -86810[ new IfV9pyf()[ false.bD]]]).xz1r9wdJ()).QAtct5DzlvQh()) while ( this.JiqyE80ws6GM()) ;
void[][][] EKFVRao = -!X5jn2pHi19ii()[ this[ new d3Sb5y().jsUOQS19xY_Tdz]];
int[] _FzpYujrJh4 = new wPmKaw3gS[ !new void[ ( new boolean[ !YLrvTyFteX.E0TNt()][ _h051glzbpG2ni.ICK5pX4])[ true.nYTKCJP1KjF8Vm()]].mJhiRI()][ 400199.ALmkirFzrJpr] = 844584208.NDemUIc4sgS0a();
while ( -!!true.vdrL1D()) !this.k7VYhGPLHZP;
void[] CivqILbndXb;
}
public static void clCGh0R0t87nx (String[] ybUgD) {
if ( !T6a().lM) while ( !-!--!-!new nrF()[ true[ -!( false[ !--true[ null.PQdAT()]]).wI]]) ;
if ( new llwUD8La4ytgxj()[ false.bxBcTCuqaUHy7()]) {
{
int iZd2n3JhSHiOe;
}
}else {
int iz9Trc4ye;
}
void[][][][] ypTf = -( !--!new J7POz[ !-AZGvBaH()[ null.ea()]].NKxCY())[ LUBB1[ new void[ new m().ujyNKQU][ !XaXFm().X7pIpyq]]] = --this[ 820471[ ---!V0s1l_()[ -!( ---null.vV_0kZhNGK0Wq())[ -!----55677003.Opr2WgOoMa]]]];
}
public int VuOQPvoVmM08 () throws IwSrra8y3Zm81X {
boolean hg2LF2vjC;
boolean dnZz6Sa;
V_z5 AhgUb3;
if ( !true[ !----C7UwFSso325Jq().hogHRJFrbbC()]) while ( !---360536190[ -this.GLsB1()]) {
;
}else !--!bQNK4UzO[ ( -EKsTFYn9OAbEA.d9vCI)[ -!4226832.sBuw97ZhZv6Z()]];
;
void d;
N2fxL1rmyY[][][][][] iLpRJ2ayQ28GO = new int[ new boolean[ !-this.EiiuH0N].AoSO8Lt].rgPlWtEqj();
void[][] HqXsh2GrbZcyaV;
int wwGjbaGTN;
while ( !( oe5Pd7Fv[ !true.i4]).cHI3Ta3r()) while ( !new void[ -true[ -!new G4().eWcJGf1zroil]][ -rP[ -!-3623.xwU13p0Vyt]]) ;
return;
!-true.Audxw8PfZ();
return !-mXDtB.z36xO6lIuq1QC5();
boolean[] CT6llJm = 687830[ -new ImLRhg2az()[ -!--D()[ -!!--!-!false.n8wW6_EuoZ7()]]];
}
public kq9bGJZi0uQfWN o;
public FZxDO5YPd9 WcbhMC;
public int[] TIbJKbyTyNS;
public void[] cAHd5To_hvkEH;
public int[][] d (void tI_tnRTFMRAZy) throws v0j9KVhVFc9 {
return !!!null.wIIULlcQSKN4i();
}
public int[][][][][][] O;
public static void vKww (String[] w) {
int mZ1v8;
while ( true.WEgxMEy7W()) if ( -false[ new wXr0AoWQVaiz().WipM7C7()]) {
YtbS9dsLp A4Cr_SrkT;
}
VA7bKf TkaTFqjfdneDG = -TLa72wsIl3[ !null[ !!t0nY49LEb3z.B94Lr1H]] = !--this.e();
while ( --JDWun.Eqd()) !J_pDYFWpO().xEJGx0Asl();
;
void j = ----null.mB() = ( false[ !new aIdq[ new qVHfbjGh().OPiz].ZS0mXc()]).YpjjH;
while ( !!( !!-oVxH9Ln2hb_.Sr0M0())[ ( new boolean[ ----this[ -new void[ l_()[ null.GSzR27U()]].fV7ec0PU]].atTgoNYAypu())[ !YtfkKP8().V]]) {
void[] R;
}
{
new p()[ TTqAdwqH.sxaPIY0n8];
f IYaI;
void[][][] b5J1iG;
void yYjddmxSi1lSC;
if ( !false.Bm5vXm) return;
while ( !!zqr__0M()[ false[ -----new void[ _().L63ZKAZiv].q]]) ;
if ( !cRW8_.gve()) {
!--!--( new lxTU7().jAch())[ true.pmFKZ65X9_q()];
}
void KUfEcB;
void AkfV22Y5hR;
int LCHpDvkLDo;
eZlxp9bdaAgdg[] R;
return;
void VpTvaTSPj56HMP;
SDoiGWGRQHQ()[ true.IBYxAeK];
}
boolean vOzoibES12Xygx = -!841594638.rYhGyi5();
while ( -new void[ !!!null.EiAfzVsCf()][ !-new jpS7YHjAU4z24().djf92ubNgt()]) {
;
}
{
void zT;
;
}
---OScb3qN1qCQrj3().G8mvsdS2HJ5;
boolean[][][][] RcBNlB2tHPI;
return;
}
public void[][][] O;
}
class dD9_BT {
}
class Cz {
public static void BCY9FBkvsfEcB8 (String[] n_YtgFKM) {
{
{
if ( this[ ( b7eENB_ew2MMTf.Gv()).HDV8nu1SjPjdm2]) while ( -!null.Ku5) ;
}
{
{
;
}
}
void Z5BN;
return;
boolean[][][][] C;
}
while ( -70026.j3tuNl) {
{
{
void[] kB;
}
}
}
while ( !!Yq2lK.vdJMk) return;
int xKnsrVFgYWNN;
!new boolean[ ( !!!null[ !!---true.DMDj()])[ false.TH8LyDzr]]._H1bpMULBB3kK();
wqFs93TI7y1[] KldpZMRfmnIe_;
boolean sA;
void LihD1 = -!-false.ixQMc_0jzhefE;
;
{
;
!!null[ -qnMVpB3[ true.Ena()]];
;
int[][] b;
void tR_FOUXLnQyRpf;
boolean[][] CozpKXeYJ;
void YiZK4O8dohXj8C;
}
void IUJDnI6;
while ( zNtJypO().zAjvSabh7pr3) while ( !this.TVhkJWwF3()) while ( -( new void[ -( AlRNwj3[ new o0NJT49()[ null.Aq()]]).ImDB8N()].vHIqDKC()).CFNeZI) HnlrOp98._I4r;
Jzxqp[][][][][] jF;
{
ACxrVQ9A xsmgdG;
if ( new int[ vWUSqN.itdV].Laz()) if ( !!R1I().pzhEFL2rr) !false[ new LIA9Mp[ !--_4AC19rgEg()[ true.GF7W7s]][ new int[ ( rYnQvY().DQR5()).ZHBqdhIE()].znIK0E67gz]];
boolean zEjjgmyjlGkA8;
while ( true.tf3g_bxHAN_PiZ) PKzGsi()[ jzyo_xcq.ucOK5c1()];
WWo[][] O8nkatdokFUnk;
boolean AB4j;
PzRDgOawXjHpLa[][] H_v0vj;
while ( vcqVPTrpfrP[ this[ !true[ this.aj2iBvE]]]) return;
;
void[] _1CPE;
while ( 306[ new hs()[ false.biIl3oaXCp]]) while ( !!true.Qd0g8vFl1gDf) return;
{
if ( !( -!null.EO2c).YLgDdOJqvDkV()) while ( 112452.VOtLTfcFFqDc()) ;
}
cJ8P1r[][] j;
8.xj();
int fg;
if ( o0Y5[ null.FsoUNPAoy9hO]) while ( 61674162[ null[ this.EQn0dbgddrpaw()]]) g().VPsKNBA();
}
new qh2oLprT9D()[ -H().vG()];
int[][] fFheo = this.CRb7 = new int[ true.ggsv_an2()].cYI0xTZ2uIIohW;
}
public static void fDCo (String[] DmOhHA4i) throws Wo4 {
while ( s6fvObch()[ JwixLkg81Kv7uZ.xLIXAYXw]) null.NBXRKFU;
{
boolean[] JDwRHYm;
void[] e2nbPR9p;
void[] k2pULBJubg5yY;
UknyEUdluwAd g5tKdwvqDgxf5N;
}
{
boolean _A6SRjVJ;
int f6IuUuzbP3_4;
!--this.yJ();
int oQV60GZ49mhmU;
;
if ( --new Xg[ !-!-!!false.ERi4maAc][ M_1T[ null[ new void[ false[ !!!--!!-!a9ZpoljJnajc_p().RiCY]].HOiz1dExAzw()]]]) new yEGafWQYSbt66[ !null.w8Jpj4e()].TQySLhTPx1m;
void[] fTOiqMsD;
--new l23qpGO().FueoJzFWZ7XJGL;
{
;
}
if ( !!this.B) {
;
}
boolean[] alU58xlErbxnL;
while ( -null.bwH8N()) while ( -!----1197595[ -new ulBm[ new void[ !!-new void[ OCSU.xF3FrfrVPZ].Z][ this[ new H0().brsUd2HneNT]]].RmJjbF1Bi0()]) return;
}
t5hD2B6h93bh5 l293IHKU;
MLa[] dKeRW;
;
boolean[][] F4MTUrllO = true.ysyRIwCIo53mQ;
boolean T8JS5h0myszU4 = -!!!!-( false[ false.toU15R()]).dTLnFkR();
{
47671.nZuJ55Si_();
( new boolean[ false.CwBQeleJfz9tT].upd2scYaGuU).ko9s();
if ( !null[ !!z89()[ this[ false.xO2YX7piH]]]) ;
SS4Z wEmw;
int[] ALazRQFDwF_;
int[] Mri6dU17crM;
YBk_ TUee7X8;
YemHb7b1[][][][][] MpFO7ObyZiPpjN;
ctgDU x0GRw23awW;
boolean l1SJX7kAbe9gu7;
;
int[][][][] Zo6ssQhNUXTC;
iKAucxIheD3 AkM9H49;
}
if ( waE2bqgMMQ.CMHst_9Wzv) while ( false.pDbF()) {
boolean JRgyS;
}
boolean[][][] abO9EHTJxkem;
while ( new boolean[ false.K4p7PK()].XOZJ7L48) return;
}
public static void qZuZ6GgcjqgC6 (String[] ho0RIP5YZ7G) throws lb {
void[][] OkYgo9b31mWz;
new a6bdncJKzAx5v5().ReXlY5();
boolean rZlAAM9T4Afh;
while ( !456630709.DYezVG61Mt0()) if ( -t2SU2[ -!!f.EFz]) {
return;
}
}
public static void MxCu_NAt (String[] nvkOqC) {
A[] FmJHwjVL;
void bOhWbrqSt8Nr;
{
if ( new void[ 89.Cj].vL9xGvl()) false[ 80206339.bUGN()];
boolean bosVRi2Gdbj;
void[] tF;
if ( --!this.Mopp6f180Uu) return;
{
return;
}
}
lQvXqj().U3tNl5FuzA;
DUfGEXMa()[ new PwZahsJHpdcVF0().zFNspPqQ()];
new LDokTJ().J1dP22bdUxV7;
;
int fQDrM;
boolean[] Im1eqxQ3NCchZ = false.V1ztqD;
void WeJnhLhzHAE = new IMLs6wwbU()[ !-( !false.pDD7()).E9XCp2pjwM()] = -( false._dbS()).VlhhSlrc1();
}
public int[][] BKPJlul7o5 (int[][] e88h, dGS0[] zcf7ZCeTDjDKKU, boolean ZB13SyCfCCdFCX, void[][][] AeJQ9JE2s) {
;
null[ -!new eH0D7ivNt().V()];
if ( ----null.BwJfSxsw_Jh) return;
boolean cNy80w = -!U4Nb()[ true[ ( Irv6.dv4dC())[ IUSUS4().GxAv]]] = h7qurRSjqsXz8().w8igbI;
TTioQ9Grs Y;
while ( --new yPH()[ !new void[ -this.GqcJHS4Sv()].vgVKaV()]) if ( !-CTo8U[ !( true.G3rPmk())[ !-!null[ !5591908[ false.Sr3S9kh8Z7N()]]]]) return;
int yJm0Q0UaU03Qq;
}
public static void _va7qU2qk (String[] ZUI2WErnMvR) {
void WSwQvnHFu;
if ( UtgyBD4gudhYzb.zkYUrSWXa) if ( !( -!!( ---b_Su02tjMh()[ Lg6P2uzTa().rYlCskxF3tOa]).yGY7Zq1FRrf())[ EJoDEhiG2Pv13Q()[ this.mq3ZVJO()]]) {
return;
}else -this.NR7Rj;
;
void SjET6;
boolean[][][][][][][][] TCxTwMMhz;
int p = L72a.Et8M();
while ( -!DiAodxspTBj.Bc72uuvstgT7K()) ;
boolean t;
return -910280[ !--( this[ tPfz2kEBBy().d2mCj3q()])[ Cdd03JZPmPIC1m()[ -null[ !-HmIcaPOdeyP6V[ null[ -new int[ G89nchvrM9().MHNz4Jb9V][ -!!new boolean[ -177314305.Y0S][ this.a3]]]]]]]];
UVkgJ13xMM ILv9x = -541110[ 2.x256];
boolean[][] F;
Newe GdTP = new nbG6Xe6GeL5ilx().jnmBI6dA7R();
M14MRdLh[] tmCIKUYn = !false[ --!!false.QTz()] = 23.wjeNO();
int mA3Vqe;
vzcTdi4EguxS0[][][] HGhIzw = null[ null.XYC()];
while ( --new void[ !--xu1[ 7179[ new boolean[ !Z0gDYnQj3H2z.wGDs5KRcDnliY()].FfhOAhjh()]]].huN7Z4df()) if ( -!( cHzwGdyvJbzi_.cYJ7_3v9).Nm()) new riH2o().hixbPDI1();
y9vVdJaG8jlAw[][] y;
int oh0r2nex6hatD = !new b()[ true.uKf()];
if ( -!!!new boolean[ Q3zW.gLih8()].D5R()) {
boolean k;
}
;
}
public boolean yiA;
}
class P53KcIfCTkTRuW {
public boolean[][] epcJxA8uW0a (boolean[][][][] WbjN007DCLxtZ) throws Q9QsZlyI7n {
{
void pjgO;
while ( !-hHuUypFg5Tg().k) -!!!new Ug[ -!500200943.PUJ()].Ri0;
{
int[][] rf5XnFSSoef;
}
void[][] CArmmivV;
while ( new zD().FJqjYIsX) return;
void IvmTIJnjo1;
if ( L().qPbR7X()) ;
while ( !--!Cw940eryWUvCJG().nDAB1iY()) {
int[] mzcFm1jDNm;
}
;
}
;
!!---new boolean[ -CcEPLrKmy.v].ClM1ZyzoJcW_;
while ( ( !Iyfz6.owkGkZ()).STGg41A8JcCPeX()) false.ctOU1lJUCn8zKX;
int[] OhBMTe3Uf86;
boolean jUSY_0K98Q = uKc_7tlJV.Z1edyI4u();
void s3 = new P().a() = !!!--null[ !new void[ new yJd0Gn()[ null.gBxOlBomHzwa()]][ this.P7FJf()]];
void mwaFktG6Z;
if ( this.Lzav7sPf0KtdT) !--new int[ null.vbMS9N()].wJolE1VvB9eu;
;
YLm1x[] w345a7xXL = !-( ---( YvZK6EbsAi[ -!1577[ --true[ 707854815[ !!sO().jcWZh8eehGA()]]]])[ fKDhyuE9Ww3.oSyr8NRIuOmYb()]).ECvNug;
if ( true[ ---!!w25THpYOlo.Mem9n7M()]) ;else ;
}
public RJPe98qdg[][][] tO;
public static void hCZZV1 (String[] T7UCEThC) {
while ( !bTo().NuPilyHzv()) ;
int xEbuOc = -A98().DO7Vzx() = !!-null[ !-false.y8Q];
{
{
return;
}
ZpJPH8Z4 DjpZ;
!null[ !-!MaeUDHRjTNF9n().U2ydwlmY()];
{
bs1 Gi3Mp;
}
if ( 200985500.rNR8()) ;
int[][][][][][][] I;
}
YqdU[][] ZdxgGJcr = -!-new a5CLpQiKe().ubGlmReIwym();
Qv3F[][] BB4YfepxY;
rBsPY_c[] FQLHpyPT8Sd;
;
Bey_2rDzHt hKAqh62uVvGY5C = new int[ !----new void[ !!-!!( -( true.znqn4D9b9epRpH())[ new Vx90Tm().Xmt]).IwE3CxPjU][ -rORpnVTQ_P9Au.yrwDO4EmK]].WV7XM() = PW().tsUPAxRUE9Oo_;
int[] MUeeLv7 = !!false[ this[ new boolean[ -!-true.n9yJsLcscE()].tx2WmlbdwJya3t()]] = !false.QownoUhw;
null.QT93S;
CYFHtSLZ2b[][][] Ossrr2;
;
BKmTRiJ[][] w = --!-new Ax4[ !xjwhLDj8PYD()[ !--XnLNDLEgGH().umHmvVrgNHI7]].Nb6t() = -true.G();
int B0NC_;
boolean xukzjdNxGScWt;
}
public boolean[][][] kL1Oqck9kWs;
}
class BbS {
}
| 38.21134 | 285 | 0.497594 |
b538a6d03ddb3df3d6d31b5e9d598c1107e14a3b | 4,639 | /*
* Copyright 2021 Verizon Media
*
* 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.yahoo.athenz.common.config;
import static org.testng.Assert.*;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.testng.annotations.Test;
import java.util.List;
public class AuthzDetailsTest {
@Test
public void testAthenzDetailsEntity() throws JsonProcessingException {
final String jsonData = "{\"type\":\"message_access\",\"roles\":[{\"name\":\"msg-readers\"," +
"\"optional\":true},{\"name\":\"msg-writers\",\"optional\":false},{\"name\":" +
"\"msg-editors\"}],\"fields\":[{\"name\":\"location\",\"optional\":true}," +
"{\"name\":\"identifier\",\"optional\":false},{\"name\":\"resource\"}]}";
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
AuthzDetailsEntity entity = jsonMapper.readValue(jsonData, AuthzDetailsEntity.class);
assertNotNull(entity);
assertEquals(entity.getType(), "message_access");
List<AuthzDetailsField> roles = entity.getRoles();
assertNotNull(roles);
assertEquals(roles.size(), 3);
assertEquals(roles.get(0).getName(), "msg-readers");
assertTrue(roles.get(0).isOptional());
assertEquals(roles.get(1).getName(), "msg-writers");
assertFalse(roles.get(1).isOptional());
assertEquals(roles.get(2).getName(), "msg-editors");
assertFalse(roles.get(2).isOptional());
List<AuthzDetailsField> fields = entity.getFields();
assertNotNull(fields);
assertEquals(fields.size(), 3);
assertEquals(fields.get(0).getName(), "location");
assertTrue(fields.get(0).isOptional());
assertEquals(fields.get(1).getName(), "identifier");
assertFalse(fields.get(1).isOptional());
assertEquals(fields.get(2).getName(), "resource");
assertFalse(fields.get(2).isOptional());
// valid and invalid field names
assertTrue(entity.isValidField("location"));
assertTrue(entity.isValidField("identifier"));
assertTrue(entity.isValidField("resource"));
assertFalse(entity.isValidField("uuid"));
}
@Test
public void testAthenzDetailsEntityInvalidJson() {
final String jsonData = "{\"type\":\"message_access\",\"roles\":[{\"name\"";
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
try {
jsonMapper.readValue(jsonData, AuthzDetailsEntity.class);
fail();
} catch (JsonProcessingException ignored) {
}
}
@Test
public void testAthenzDetailsEntityOptionalFields() throws JsonProcessingException {
final String jsonData = "{\"type\":\"message_access\"}";
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
AuthzDetailsEntity entity = jsonMapper.readValue(jsonData, AuthzDetailsEntity.class);
assertNotNull(entity);
assertEquals(entity.getType(), "message_access");
assertNull(entity.getRoles());
assertNull(entity.getFields());
}
@Test
public void testAthenzDetailsEntityUnknownFields() {
final String jsonData = "{\"type\":\"message_access\",\"data\":\"test\"}";
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
try {
jsonMapper.readValue(jsonData, AuthzDetailsEntity.class);
fail();
} catch (JsonProcessingException ignored) {
}
}
@Test
public void testIsValidFieldNull() {
AuthzDetailsEntity entity = new AuthzDetailsEntity();
assertNull(entity.getFields());
assertFalse(entity.isValidField("type"));
}
}
| 35.143939 | 102 | 0.664798 |
b0113f77010e83ba61147d43dac6bb62acb8133a | 2,031 | package nu.esox.gui.aspect;
import java.util.*;
import java.awt.*;
import javax.swing.*;
import nu.esox.util.*;
public class VisiblePredicateAdapter implements ObservableListener
{
private final LinkedList<JComponent> m_trueComponents = new LinkedList<JComponent>();
private final LinkedList<JComponent> m_falseComponents = new LinkedList<JComponent>();
private boolean m_isTrue = false;
public VisiblePredicateAdapter( PredicateIF p )
{
this( new JComponent [] { },
new JComponent [] { },
p );
}
public VisiblePredicateAdapter( JComponent trueComponent,
JComponent falseComponent,
PredicateIF p )
{
this( ( trueComponent == null ) ? null : new JComponent [] { trueComponent },
( falseComponent == null ) ? null : new JComponent [] { falseComponent },
p );
}
public VisiblePredicateAdapter( JComponent [] trueComponents,
JComponent [] falseComponents,
PredicateIF p )
{
for ( JComponent c : trueComponents ) m_trueComponents.add( c );
for ( JComponent c : falseComponents ) m_falseComponents.add( c );
p.addObservableListener( this );
m_isTrue = p.isTrue();
update( m_isTrue );
}
public void addTrue( JComponent c ) { m_trueComponents.add( c ); update( m_isTrue ); }
public void addFalse( JComponent c ) { m_falseComponents.add( c ); update( m_isTrue ); }
public void valueChanged( ObservableEvent ev )
{
update( ( (PredicateIF) ev.getSource() ).isTrue() );
}
private void update( boolean enabled )
{
m_isTrue = enabled;
for ( JComponent c : m_trueComponents ) c.setVisible( enabled );
enabled = ! enabled;
for ( JComponent c : m_falseComponents ) c.setVisible( enabled );
}
}
| 31.246154 | 92 | 0.577548 |
187d45e6ae786f4637f397eb276ee1895b8ffbc8 | 5,304 | package eu.modernmt.cli;
import eu.modernmt.io.IOCorporaUtils;
import eu.modernmt.model.corpus.BilingualCorpus;
import eu.modernmt.model.corpus.impl.parallel.ParallelFileCorpus;
import eu.modernmt.model.corpus.impl.properties.ParallelPropertiesCorpus;
import eu.modernmt.model.corpus.impl.tmx.TMXCorpus;
import eu.modernmt.model.corpus.impl.xliff.XLIFFCorpus;
import org.apache.commons.cli.*;
import java.io.File;
import java.util.HashMap;
import java.util.Locale;
/**
* Created by davide on 04/07/16.
*/
public class ConvertMain {
private static final HashMap<String, InputFormat> FORMATS;
static {
FORMATS = new HashMap<>();
FORMATS.put("tmx", new TMXInputFormat());
FORMATS.put("parallel", new ParallelFileInputFormat());
FORMATS.put("properties", new ParallelPropertiesInputFormat());
FORMATS.put("xliff", new XLIFFInputFormat());
}
private interface InputFormat {
BilingualCorpus parse(Locale sourceLanguage, Locale targetLanguage, File[] files) throws ParseException;
}
private static class TMXInputFormat implements InputFormat {
@Override
public BilingualCorpus parse(Locale sourceLanguage, Locale targetLanguage, File[] files) throws ParseException {
if (files.length != 1)
throw new ParseException("Invalid number of arguments: expected 1 file");
return new TMXCorpus(files[0], sourceLanguage, targetLanguage);
}
}
private static class ParallelFileInputFormat implements InputFormat {
@Override
public BilingualCorpus parse(Locale sourceLanguage, Locale targetLanguage, File[] files) throws ParseException {
if (files.length != 2)
throw new ParseException("Invalid number of arguments: expected 2 files");
return new ParallelFileCorpus(sourceLanguage, files[0], targetLanguage, files[1]);
}
}
private static class ParallelPropertiesInputFormat implements InputFormat {
@Override
public BilingualCorpus parse(Locale sourceLanguage, Locale targetLanguage, File[] files) throws ParseException {
if (files.length != 2)
throw new ParseException("Invalid number of arguments: expected 2 files");
return new ParallelPropertiesCorpus(sourceLanguage, files[0], targetLanguage, files[1]);
}
}
private static class XLIFFInputFormat implements InputFormat {
@Override
public BilingualCorpus parse(Locale sourceLanguage, Locale targetLanguage, File[] files) throws ParseException {
if (files.length != 1)
throw new ParseException("Invalid number of arguments: expected 1 file");
return new XLIFFCorpus(files[0], sourceLanguage, targetLanguage);
}
}
private static class Args {
private static final Options cliOptions;
static {
Option sourceLanguage = Option.builder("s").hasArg().required().build();
Option targetLanguage = Option.builder("t").hasArg().required().build();
Option input = Option.builder().longOpt("input").hasArgs().required().build();
Option inputFormat = Option.builder().longOpt("input-format").hasArg().required().build();
Option output = Option.builder().longOpt("output").hasArgs().required().build();
Option outputFormat = Option.builder().longOpt("output-format").hasArg().required().build();
cliOptions = new Options();
cliOptions.addOption(sourceLanguage);
cliOptions.addOption(targetLanguage);
cliOptions.addOption(input);
cliOptions.addOption(inputFormat);
cliOptions.addOption(output);
cliOptions.addOption(outputFormat);
}
public final BilingualCorpus input;
public final BilingualCorpus output;
public final Locale sourceLanguage;
public final Locale targetLanguage;
private BilingualCorpus getCorpusInstance(CommandLine cli, String prefix) throws ParseException {
String formatName = cli.getOptionValue(prefix + "-format");
InputFormat format = FORMATS.get(formatName.toLowerCase());
if (format == null)
throw new ParseException("Invalid format '" + formatName + "', must be one of " + FORMATS.keySet());
String[] arg = cli.getOptionValues(prefix);
File[] files = new File[arg.length];
for (int i = 0; i < arg.length; i++)
files[i] = new File(arg[i]);
return format.parse(sourceLanguage, targetLanguage, files);
}
public Args(String[] args) throws ParseException {
CommandLineParser parser = new DefaultParser();
CommandLine cli = parser.parse(cliOptions, args);
sourceLanguage = Locale.forLanguageTag(cli.getOptionValue('s'));
targetLanguage = Locale.forLanguageTag(cli.getOptionValue('t'));
input = getCorpusInstance(cli, "input");
output = getCorpusInstance(cli, "output");
}
}
public static void main(String[] _args) throws Throwable {
Args args = new Args(_args);
IOCorporaUtils.copy(args.input, args.output);
}
}
| 38.158273 | 120 | 0.660068 |
92c65955422b74cb6c2403333686f92f9a095f4a | 1,042 | package functionalInterface;
import java.util.function.Supplier;
/**
* @program: my-design-patterns
* @description: Supplier<T> 接口称为生产型接口，指定接口的泛型是什么，那么接口中的get（）方法就会生成什么类型的数据
* @author: Rui.Zhou
* @create: 2019-07-02 16:48
**/
public class Demo04Supplier {
//定义一个方法，方法的参数传递Supplier接口
public static String getString(Supplier<String> sup){
return sup.get();
}
//定义个方法，用于获取int数组中的元素最大值
public static Integer getMax(Supplier<Integer> sup){
return sup.get();
};
public static void main(String[] args) {
String string = getString(() -> {
//生产一个字符串并返回
return "hello";
});
System.out.println(string);
int[] arr= {1,2,0,-12,88};
Integer max1 = getMax(() -> {
//获取数组中元素的最大值并返回
int max = arr[0];
for (int i : arr) {
if (i > max) {
max = i;
}
}
return max;
});
System.out.println(max1);
}
}
| 18.607143 | 74 | 0.525912 |
8647db3d9da100669b40e58d973f62f16cb1cab5 | 6,208 | package jpg.k.simplyimprovedterrain.biome;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.BiomeManager;
import net.minecraft.world.biome.IBiomeMagnifier;
import jpg.k.simplyimprovedterrain.biome.blending.LinkedBiomeWeightMap;
import jpg.k.simplyimprovedterrain.biome.blending.ScatteredBiomeBlender;
import jpg.k.simplyimprovedterrain.util.LinkedHashCache;
public enum CachedScatteredBiomeMagnifier implements IBiomeMagnifier {
INSTANCE;
private static final int N_ACTIVEMOST_NODES = 8;
private static final int CACHE_MAX_SIZE = 24;
private static final double SCATTERED_BLENDER_FREQUENCY = 0.078125;
private static final double SCATTERED_BLENDER_PADDING = 4.0;
private static final ScatteredBiomeBlender scatteredBiomeBlender = new ScatteredBiomeBlender(SCATTERED_BLENDER_FREQUENCY, SCATTERED_BLENDER_PADDING, 16);
private static final int gridPadding = (int)Math.ceil(scatteredBiomeBlender.getInternalBlendRadius() * 0.25) + 3; // TODO is 3 too much?
private static final int paddedGridWidth = 5 + 2 * gridPadding; // 1/4 chunk width, +1 for end bounds, + gridPadding on each side
private static final int paddedGridWidthSq = paddedGridWidth * paddedGridWidth;
private static LinkedHashCache<ProviderCoordinate, Biome[]> cache = new LinkedHashCache<>(N_ACTIVEMOST_NODES, CACHE_MAX_SIZE);
private void CachedScatteredBiomeMagnifier() {
}
public Biome getBiome(long seed, int x, int y, int z, BiomeManager.IBiomeReader biomeReader) {
ProviderCoordinate key = new ProviderCoordinate(biomeReader, seed, x & (int)0xFFFFFFF0, z & (int)0xFFFFFFF0);
Biome[] biomes = cache.get(key, CachedScatteredBiomeMagnifier::generateBiomes);
Biome biome = biomes.length != 1 ? biomes[((z & 0xF) << 4) | (x & 0xF)] : biomes[0];
return biome;
}
private static Biome[] generateBiomes(ProviderCoordinate key) {
LinkedBiomeWeightMap startEntry = generateBiomeBlending(key.biomeReader, key.seed, key.x, key.z);
return generateBiomes(startEntry);
}
private static Biome[] generateBiomes(LinkedBiomeWeightMap startEntry) {
if (startEntry.getNext() != null) {
Biome[] biomes = new Biome[256];
for (int i = 0; i < 256; i++) {
double bestWeight = Double.NEGATIVE_INFINITY;
Biome bestBiome = null;
for (LinkedBiomeWeightMap entry = startEntry; entry != null; entry = entry.getNext()) {
double thisWeight = entry.getWeights()[i];
if (thisWeight > bestWeight) {
bestWeight = thisWeight;
bestBiome = entry.getBiome();
}
}
biomes[i] = bestBiome;
}
return biomes;
} else {
return new Biome[] { startEntry.getBiome() };
}
}
private static LinkedBiomeWeightMap generateBiomeBlending(BiomeManager.IBiomeReader biomeReader, long seed, int worldChunkX, int worldChunkZ) {
int worldChunkXScaled = worldChunkX >> 2;
int worldChunkZScaled = worldChunkZ >> 2;
Biome[] lookupGrid = new Biome[paddedGridWidthSq];
for (int z = 0; z < paddedGridWidth; z++) {
for (int x = 0; x < paddedGridWidth; x++) {
lookupGrid[z * paddedGridWidth + x] = biomeReader.getNoiseBiome(x + (worldChunkXScaled - gridPadding), 0, z + (worldChunkZScaled - gridPadding));
}
}
return scatteredBiomeBlender.getBlendForChunk(0, worldChunkX, worldChunkZ, (double x, double z) -> {
x *= 0.25;
z *= 0.25;
int xRound = (int)(x > 0 ? x + 0.5 : x - 0.5);
int zRound = (int)(z > 0 ? z + 0.5 : z - 0.5);
int lxRound = xRound + (gridPadding - worldChunkXScaled);
int lzRound = zRound + (gridPadding - worldChunkZScaled);
Biome biome = lookupGrid[lzRound * paddedGridWidth + lxRound];
// Give rivers a bigger area.
double closestRiverTileDistSq = Double.POSITIVE_INFINITY;
for (int rz = zRound - 2; rz <= zRound + 2; rz++) {
int b = rz > zRound - 2 && rz < zRound + 2 ? 2 : 1; // Check a rounded 5x5 not a full 5x5
for (int rx = xRound - b; rx <= xRound + b; rx++) {
double distSq = (rz - z) * (rz - z) + (rx - x) * (rx - x);
if (distSq >= closestRiverTileDistSq) continue;
Biome thisBiome = lookupGrid[(rz + (gridPadding - worldChunkZScaled)) * paddedGridWidth + (rx + (gridPadding - worldChunkXScaled))];
if (thisBiome.getCategory() != Biome.Category.RIVER) continue;
biome = thisBiome;
closestRiverTileDistSq = distSq;
}
}
return biome;
});
}
public static LinkedBiomeWeightMap generateBiomeBlendingAndCacheMap(BiomeManager.IBiomeReader biomeReader, long seed, int worldChunkX, int worldChunkZ) {
LinkedBiomeWeightMap startEntry = generateBiomeBlending(biomeReader, seed, worldChunkX, worldChunkZ);
ProviderCoordinate key = new ProviderCoordinate(biomeReader, seed, worldChunkX, worldChunkZ);
cache.get(key, (k) -> generateBiomes(startEntry));
return startEntry;
}
private static class ProviderCoordinate {
BiomeManager.IBiomeReader biomeReader;
long seed;
int x, z;
public ProviderCoordinate(BiomeManager.IBiomeReader biomeReader, long seed, int x, int z) {
this.biomeReader = biomeReader;
this.seed = seed;
this.x = x;
this.z = z;
}
public int hashCode() {
return Long.hashCode(seed) ^ (x * 509) ^ (z * 2591) ^ (System.identityHashCode(biomeReader) * 515153);
}
public boolean equals(Object other) {
if (!(other instanceof ProviderCoordinate)) return false;
ProviderCoordinate o = (ProviderCoordinate) other;
return this.biomeReader == o.biomeReader && this.seed == o.seed && this.x == o.x && this.z == o.z;
}
}
}
| 46.676692 | 161 | 0.628866 |
9c48b6c733225473e03c7b87a2c90152f5c0e18e | 554 | package com.techmojo.ratelimiter.services;
import com.techmojo.ratelimiter.entities.Ticket;
import com.techmojo.ratelimiter.repository.TicketRepository;
import org.springframework.stereotype.Service;
@Service
public class TicketServiceImpl implements TicketService {
private final TicketRepository ticketRepository;
public TicketServiceImpl(TicketRepository ticketRepository) {
this.ticketRepository = ticketRepository;
}
public Ticket getTicket(Long ticketId) {
return ticketRepository.getTicket(ticketId);
}
}
| 26.380952 | 65 | 0.792419 |
f03864ca74cc9c7426c703a47442eafc40934702 | 448 | /*
* 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 mz.e.aula3;
/**
*
* @author Valter Massango
* @author Jose Seie
* @author Filipe Mangue
* @author José Romão
* @author Aly Macome
* @author Abdul Rasac
* @author Adrian Uaeca
* @author Efraime Mutole
*/
public class TiposPrimitivos {
}
| 20.363636 | 79 | 0.696429 |
91f1f55e95f0f26ea1798f242ef29ce70c07b3ce | 1,868 | package com.google.android.gms.internal;
import android.app.Activity;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
import android.view.ViewTreeObserver.OnScrollChangedListener;
import com.google.android.gms.ads.internal.zzp;
@zzha
public final class zzja {
private boolean zzLA;
private boolean zzLB;
private OnGlobalLayoutListener zzLC;
private OnScrollChangedListener zzLD;
private Activity zzLy;
private boolean zzLz;
public zzja(Activity activity, OnGlobalLayoutListener onGlobalLayoutListener, OnScrollChangedListener onScrollChangedListener) {
this.zzLy = activity;
this.zzLC = onGlobalLayoutListener;
this.zzLD = onScrollChangedListener;
}
private void zzho() {
if (this.zzLy != null && !this.zzLz) {
if (this.zzLC != null) {
zzp.zzbx().zza(this.zzLy, this.zzLC);
}
if (this.zzLD != null) {
zzp.zzbx().zza(this.zzLy, this.zzLD);
}
this.zzLz = true;
}
}
private void zzhp() {
if (this.zzLy != null && this.zzLz) {
if (this.zzLC != null) {
zzp.zzbz().zzb(this.zzLy, this.zzLC);
}
if (this.zzLD != null) {
zzp.zzbx().zzb(this.zzLy, this.zzLD);
}
this.zzLz = false;
}
}
public void onAttachedToWindow() {
this.zzLA = true;
if (this.zzLB) {
zzho();
}
}
public void onDetachedFromWindow() {
this.zzLA = false;
zzhp();
}
public void zzhm() {
this.zzLB = true;
if (this.zzLA) {
zzho();
}
}
public void zzhn() {
this.zzLB = false;
zzhp();
}
public void zzk(Activity activity) {
this.zzLy = activity;
}
}
| 24.906667 | 132 | 0.557281 |
f223763641e466750eb6d3f2419bdf1520fb3db6 | 518 | package com.rtalpha.base.mongo.crud;
import javax.annotation.Nonnull;
import com.rtalpha.base.kernel.dto.BaseDto;
import com.rtalpha.base.mongo.document.BaseDocument;
/**
* Superclass of all database services for local CRUD
*
* @author Ricky
* @param <Doc>
* @since Jun 29, 2017
*/
public interface CrudService<Dto extends BaseDto, Doc extends BaseDocument> {
/**
* DO NOT call this method explicitly which is intended to be internal use
*/
@Nonnull
ServiceMetaData<Dto, Doc> getServiceMetaData();
}
| 22.521739 | 77 | 0.743243 |
0bf4f103a10f68d0626ec0e38d1918f5a0ef0dac | 3,055 | package com.sequenceiq.cloudbreak.controller;
import java.util.Set;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Named;
import javax.transaction.Transactional;
import javax.transaction.Transactional.TxType;
import org.springframework.core.convert.ConversionService;
import org.springframework.stereotype.Controller;
import com.sequenceiq.cloudbreak.api.endpoint.v3.RecipeV3Endpoint;
import com.sequenceiq.cloudbreak.api.model.RecipeRequest;
import com.sequenceiq.cloudbreak.api.model.RecipeResponse;
import com.sequenceiq.cloudbreak.api.model.RecipeViewResponse;
import com.sequenceiq.cloudbreak.common.type.ResourceEvent;
import com.sequenceiq.cloudbreak.domain.Recipe;
import com.sequenceiq.cloudbreak.domain.workspace.User;
import com.sequenceiq.cloudbreak.service.RestRequestThreadLocalService;
import com.sequenceiq.cloudbreak.service.recipe.RecipeService;
import com.sequenceiq.cloudbreak.service.user.UserService;
import com.sequenceiq.cloudbreak.util.WorkspaceEntityType;
@Controller
@Transactional(TxType.NEVER)
@WorkspaceEntityType(Recipe.class)
public class RecipeV3Controller extends NotificationController implements RecipeV3Endpoint {
@Inject
private RecipeService recipeService;
@Inject
@Named("conversionService")
private ConversionService conversionService;
@Inject
private UserService userService;
@Inject
private RestRequestThreadLocalService restRequestThreadLocalService;
@Override
public Set<RecipeViewResponse> listByWorkspace(Long workspaceId) {
return recipeService.findAllViewByWorkspaceId(workspaceId).stream()
.map(recipe -> conversionService.convert(recipe, RecipeViewResponse.class))
.collect(Collectors.toSet());
}
@Override
public RecipeResponse getByNameInWorkspace(Long workspaceId, String name) {
Recipe recipe = recipeService.getByNameForWorkspaceId(name, workspaceId);
return conversionService.convert(recipe, RecipeResponse.class);
}
@Override
public RecipeResponse createInWorkspace(Long workspaceId, RecipeRequest request) {
Recipe recipe = conversionService.convert(request, Recipe.class);
User user = userService.getOrCreate(restRequestThreadLocalService.getCloudbreakUser());
recipe = recipeService.create(recipe, workspaceId, user);
notify(ResourceEvent.RECIPE_CREATED);
return conversionService.convert(recipe, RecipeResponse.class);
}
@Override
public RecipeResponse deleteInWorkspace(Long workspaceId, String name) {
Recipe deleted = recipeService.deleteByNameFromWorkspace(name, workspaceId);
notify(ResourceEvent.RECIPE_DELETED);
return conversionService.convert(deleted, RecipeResponse.class);
}
@Override
public RecipeRequest getRequestFromName(Long workspaceId, String name) {
Recipe recipe = recipeService.getByNameForWorkspaceId(name, workspaceId);
return conversionService.convert(recipe, RecipeRequest.class);
}
}
| 38.670886 | 95 | 0.785597 |
02ee5e03dbb6254043b793cf30ea058061e0460b | 964 | package com.egoveris.te.base.model;
import com.egoveris.te.base.model.rest.FormsWsDTO;
import com.egoveris.te.model.model.ValidateUser;
public class SaveFormRequestAppDTO {
private FormsWsDTO formInput;
private TareaAppDTO task;
private ValidateUser user;
/**
* @return the formInput
*/
public FormsWsDTO getFormInput() {
return formInput;
}
/**
* @param formInput
* the formInput to set
*/
public void setFormInput(FormsWsDTO formInput) {
this.formInput = formInput;
}
/**
* @return the task
*/
public TareaAppDTO getTask() {
return task;
}
/**
* @param task
* the task to set
*/
public void setTask(TareaAppDTO task) {
this.task = task;
}
/**
* @return the user
*/
public ValidateUser getUser() {
return user;
}
/**
* @param user
* the user to set
*/
public void setUser(ValidateUser user) {
this.user = user;
}
}
| 16.62069 | 50 | 0.618257 |
6cc3224e8ded74e8418784631e6e0255b0436a70 | 10,192 | package com.totoro.db.entity;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
*
* This class was generated by MyBatis Generator.
* This class corresponds to the database table product
*/
public class Product implements Serializable {
/**
* Database Column Remarks:
* 商品id
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.id
*
* @mbg.generated
*/
private Long id;
/**
* Database Column Remarks:
* 商品名称
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.name
*
* @mbg.generated
*/
private String name;
/**
* Database Column Remarks:
* 商品描述
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.description
*
* @mbg.generated
*/
private String description;
/**
* Database Column Remarks:
* 商品缩略图
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.thumb
*
* @mbg.generated
*/
private String thumb;
/**
* Database Column Remarks:
* 商品图片
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.picture
*
* @mbg.generated
*/
private String picture;
/**
* Database Column Remarks:
* 商品价格
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.price
*
* @mbg.generated
*/
private BigDecimal price;
/**
* Database Column Remarks:
* 商品状态 【0：下架；1：上架；2：审核中】
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.status
*
* @mbg.generated
*/
private Byte status;
/**
* Database Column Remarks:
* 所属类别
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.category_id
*
* @mbg.generated
*/
private Long categoryId;
/**
* Database Column Remarks:
* 创建时间
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.create_time
*
* @mbg.generated
*/
private LocalDateTime createTime;
/**
* Database Column Remarks:
* 修改时间
*
* This field was generated by MyBatis Generator.
* This field corresponds to the database column product.update_time
*
* @mbg.generated
*/
private LocalDateTime updateTime;
/**
* This field was generated by MyBatis Generator.
* This field corresponds to the database table product
*
* @mbg.generated
*/
private static final long serialVersionUID = 1L;
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.id
*
* @return the value of product.id
*
* @mbg.generated
*/
public Long getId() {
return id;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.id
*
* @param id the value for product.id
*
* @mbg.generated
*/
public void setId(Long id) {
this.id = id;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.name
*
* @return the value of product.name
*
* @mbg.generated
*/
public String getName() {
return name;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.name
*
* @param name the value for product.name
*
* @mbg.generated
*/
public void setName(String name) {
this.name = name == null ? null : name.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.description
*
* @return the value of product.description
*
* @mbg.generated
*/
public String getDescription() {
return description;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.description
*
* @param description the value for product.description
*
* @mbg.generated
*/
public void setDescription(String description) {
this.description = description == null ? null : description.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.thumb
*
* @return the value of product.thumb
*
* @mbg.generated
*/
public String getThumb() {
return thumb;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.thumb
*
* @param thumb the value for product.thumb
*
* @mbg.generated
*/
public void setThumb(String thumb) {
this.thumb = thumb == null ? null : thumb.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.picture
*
* @return the value of product.picture
*
* @mbg.generated
*/
public String getPicture() {
return picture;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.picture
*
* @param picture the value for product.picture
*
* @mbg.generated
*/
public void setPicture(String picture) {
this.picture = picture == null ? null : picture.trim();
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.price
*
* @return the value of product.price
*
* @mbg.generated
*/
public BigDecimal getPrice() {
return price;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.price
*
* @param price the value for product.price
*
* @mbg.generated
*/
public void setPrice(BigDecimal price) {
this.price = price;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.status
*
* @return the value of product.status
*
* @mbg.generated
*/
public Byte getStatus() {
return status;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.status
*
* @param status the value for product.status
*
* @mbg.generated
*/
public void setStatus(Byte status) {
this.status = status;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.category_id
*
* @return the value of product.category_id
*
* @mbg.generated
*/
public Long getCategoryId() {
return categoryId;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.category_id
*
* @param categoryId the value for product.category_id
*
* @mbg.generated
*/
public void setCategoryId(Long categoryId) {
this.categoryId = categoryId;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.create_time
*
* @return the value of product.create_time
*
* @mbg.generated
*/
public LocalDateTime getCreateTime() {
return createTime;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.create_time
*
* @param createTime the value for product.create_time
*
* @mbg.generated
*/
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
/**
* This method was generated by MyBatis Generator.
* This method returns the value of the database column product.update_time
*
* @return the value of product.update_time
*
* @mbg.generated
*/
public LocalDateTime getUpdateTime() {
return updateTime;
}
/**
* This method was generated by MyBatis Generator.
* This method sets the value of the database column product.update_time
*
* @param updateTime the value for product.update_time
*
* @mbg.generated
*/
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
/**
* This method was generated by MyBatis Generator.
* This method corresponds to the database table product
*
* @mbg.generated
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", name=").append(name);
sb.append(", description=").append(description);
sb.append(", thumb=").append(thumb);
sb.append(", picture=").append(picture);
sb.append(", price=").append(price);
sb.append(", status=").append(status);
sb.append(", categoryId=").append(categoryId);
sb.append(", createTime=").append(createTime);
sb.append(", updateTime=").append(updateTime);
sb.append("]");
return sb.toString();
}
} | 25.737374 | 79 | 0.609301 |
5784d39eca36bb8a3bf8ec77bf7f36ad5821868f | 37,945 | /*
* Copyright 2019-2021 The Polypheny Project
*
* 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.
*
* This file incorporates code covered by the following terms:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.polypheny.db.rex;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.polypheny.db.algebra.operators.OperatorName;
import org.polypheny.db.algebra.type.AlgDataType;
import org.polypheny.db.algebra.type.AlgDataTypeField;
import org.polypheny.db.languages.OperatorRegistry;
import org.polypheny.db.plan.AlgOptPredicateList;
import org.polypheny.db.plan.AlgOptUtil;
import org.polypheny.db.util.Litmus;
import org.polypheny.db.util.Pair;
/**
* Workspace for constructing a {@link RexProgram}.
*
* RexProgramBuilder is necessary because a {@link RexProgram} is immutable. (The {@link String} class has the same problem: it is immutable, so they introduced {@link StringBuilder}.)
*/
public class RexProgramBuilder {
private final RexBuilder rexBuilder;
private final AlgDataType inputRowType;
private final List<RexNode> exprList = new ArrayList<>();
private final Map<Pair<RexNode, String>, RexLocalRef> exprMap = new HashMap<>();
private final List<RexLocalRef> localRefList = new ArrayList<>();
private final List<RexLocalRef> projectRefList = new ArrayList<>();
private final List<String> projectNameList = new ArrayList<>();
private final RexSimplify simplify;
private RexLocalRef conditionRef = null;
private boolean validating;
/**
* Creates a program-builder that will not simplify.
*/
public RexProgramBuilder( AlgDataType inputRowType, RexBuilder rexBuilder ) {
this( inputRowType, rexBuilder, null );
}
/**
* Creates a program-builder.
*/
private RexProgramBuilder( AlgDataType inputRowType, RexBuilder rexBuilder, RexSimplify simplify ) {
this.inputRowType = Objects.requireNonNull( inputRowType );
this.rexBuilder = Objects.requireNonNull( rexBuilder );
this.simplify = simplify; // may be null
this.validating = assertionsAreEnabled();
// Pre-create an expression for each input field.
if ( inputRowType.isStruct() ) {
final List<AlgDataTypeField> fields = inputRowType.getFieldList();
for ( int i = 0; i < fields.size(); i++ ) {
registerInternal( RexInputRef.of( i, fields ), false );
}
}
}
/**
* Creates a program builder with the same contents as a program.
*
* @param rexBuilder Rex builder
* @param inputRowType Input row type
* @param exprList Common expressions
* @param projectList Projections
* @param condition Condition, or null
* @param outputRowType Output row type
* @param normalize Whether to normalize
* @param simplify Simplifier, or null to not simplify
*/
private RexProgramBuilder( RexBuilder rexBuilder, final AlgDataType inputRowType, final List<RexNode> exprList, final Iterable<? extends RexNode> projectList, RexNode condition, final AlgDataType outputRowType, boolean normalize, RexSimplify simplify ) {
this( inputRowType, rexBuilder, simplify );
// Create a shuttle for registering input expressions.
final RexShuttle shuttle = new RegisterMidputShuttle( true, exprList );
// If we are not normalizing, register all internal expressions. If we are normalizing, expressions will be registered if and when they are first used.
if ( !normalize ) {
for ( RexNode expr : exprList ) {
expr.accept( shuttle );
}
}
final RexShuttle expander = new RexProgram.ExpansionShuttle( exprList );
// Register project expressions and create a named project item.
final List<AlgDataTypeField> fieldList = outputRowType.getFieldList();
for ( Pair<? extends RexNode, AlgDataTypeField> pair : Pair.zip( projectList, fieldList ) ) {
final RexNode project;
if ( simplify != null ) {
project = simplify.simplify( pair.left.accept( expander ) );
} else {
project = pair.left;
}
final String name = pair.right.getName();
final RexLocalRef ref = (RexLocalRef) project.accept( shuttle );
addProject( ref.getIndex(), name );
}
// Register the condition, if there is one.
if ( condition != null ) {
if ( simplify != null ) {
condition = simplify.simplify( rexBuilder.makeCall( OperatorRegistry.get( OperatorName.IS_TRUE ), condition.accept( expander ) ) );
if ( condition.isAlwaysTrue() ) {
condition = null;
}
}
if ( condition != null ) {
final RexLocalRef ref = (RexLocalRef) condition.accept( shuttle );
addCondition( ref );
}
}
}
/**
* Returns whether assertions are enabled in this class.
*/
private static boolean assertionsAreEnabled() {
boolean assertionsEnabled = false;
//noinspection AssertWithSideEffects
assert assertionsEnabled = true;
return assertionsEnabled;
}
private void validate( final RexNode expr, final int fieldOrdinal ) {
final RexVisitor<Void> validator =
new RexVisitorImpl<Void>( true ) {
@Override
public Void visitInputRef( RexInputRef input ) {
final int index = input.getIndex();
final List<AlgDataTypeField> fields = inputRowType.getFieldList();
if ( index < fields.size() ) {
final AlgDataTypeField inputField = fields.get( index );
if ( input.getType() != inputField.getType() ) {
throw new AssertionError( "in expression " + expr + ", field reference " + input + " has inconsistent type" );
}
} else {
if ( index >= fieldOrdinal ) {
throw new AssertionError( "in expression " + expr + ", field reference " + input + " is out of bounds" );
}
RexNode refExpr = exprList.get( index );
if ( refExpr.getType() != input.getType() ) {
throw new AssertionError( "in expression " + expr + ", field reference " + input + " has inconsistent type" );
}
}
return null;
}
};
expr.accept( validator );
}
/**
* Adds a project expression to the program.
*
* The expression specified in terms of the input fields. If not, call {@link #registerOutput(RexNode)} first.
*
* @param expr Expression to add
* @param name Name of field in output row type; if null, a unique name will be generated when the program is created
* @return the ref created
*/
public RexLocalRef addProject( RexNode expr, String name ) {
final RexLocalRef ref = registerInput( expr );
return addProject( ref.getIndex(), name );
}
/**
* Adds a projection based upon the <code>index</code>th expression.
*
* @param ordinal Index of expression to project
* @param name Name of field in output row type; if null, a unique name will be generated when the program is created
* @return the ref created
*/
public RexLocalRef addProject( int ordinal, final String name ) {
final RexLocalRef ref = localRefList.get( ordinal );
projectRefList.add( ref );
projectNameList.add( name );
return ref;
}
/**
* Adds a project expression to the program at a given position.
*
* The expression specified in terms of the input fields. If not, call {@link #registerOutput(RexNode)} first.
*
* @param at Position in project list to add expression
* @param expr Expression to add
* @param name Name of field in output row type; if null, a unique name will be generated when the program is created
* @return the ref created
*/
public RexLocalRef addProject( int at, RexNode expr, String name ) {
final RexLocalRef ref = registerInput( expr );
projectRefList.add( at, ref );
projectNameList.add( at, name );
return ref;
}
/**
* Adds a projection based upon the <code>index</code>th expression at a given position.
*
* @param at Position in project list to add expression
* @param ordinal Index of expression to project
* @param name Name of field in output row type; if null, a unique name will be generated when the program is created
* @return the ref created
*/
public RexLocalRef addProject( int at, int ordinal, final String name ) {
return addProject( at, localRefList.get( ordinal ), name );
}
/**
* Sets the condition of the program.
*
* <p>The expression must be specified in terms of the input fields. If
* not, call {@link #registerOutput(RexNode)} first.</p>
*/
public void addCondition( RexNode expr ) {
assert expr != null;
if ( conditionRef == null ) {
conditionRef = registerInput( expr );
} else {
// AND the new condition with the existing condition.
// If the new condition is identical to the existing condition, skip it.
RexLocalRef ref = registerInput( expr );
if ( !ref.equals( conditionRef ) ) {
conditionRef = registerInput( rexBuilder.makeCall( OperatorRegistry.get( OperatorName.AND ), conditionRef, ref ) );
}
}
}
/**
* Registers an expression in the list of common sub-expressions, and returns a reference to that expression.
*
* The expression must be expressed in terms of the <em>inputs</em> of this program.
*/
public RexLocalRef registerInput( RexNode expr ) {
final RexShuttle shuttle = new RegisterInputShuttle( true );
final RexNode ref = expr.accept( shuttle );
return (RexLocalRef) ref;
}
/**
* Converts an expression expressed in terms of the <em>outputs</em> of this program into an expression expressed in terms of the <em>inputs</em>, registers it in the list of common sub-expressions,
* and returns a reference to that expression.
*
* @param expr Expression to register
*/
public RexLocalRef registerOutput( RexNode expr ) {
final RexShuttle shuttle = new RegisterOutputShuttle( exprList );
final RexNode ref = expr.accept( shuttle );
return (RexLocalRef) ref;
}
/**
* Registers an expression in the list of common sub-expressions, and returns a reference to that expression.
*
* If an equivalent sub-expression already exists, creates another expression only if <code>force</code> is true.
*
* @param expr Expression to register
* @param force Whether to create a new sub-expression if an equivalent sub-expression exists.
*/
private RexLocalRef registerInternal( RexNode expr, boolean force ) {
final RexSimplify simplify = new RexSimplify( rexBuilder, AlgOptPredicateList.EMPTY, RexUtil.EXECUTOR );
expr = simplify.simplifyPreservingType( expr );
RexLocalRef ref;
final Pair<RexNode, String> key;
if ( expr instanceof RexLocalRef ) {
key = null;
ref = (RexLocalRef) expr;
} else {
key = RexUtil.makeKey( expr );
ref = exprMap.get( key );
}
if ( ref == null ) {
if ( validating ) {
validate( expr, exprList.size() );
}
// Add expression to list, and return a new reference to it.
ref = addExpr( expr );
exprMap.put( key, ref );
} else {
if ( force ) {
// Add expression to list, but return the previous ref.
addExpr( expr );
}
}
for ( ; ; ) {
int index = ref.index;
final RexNode expr2 = exprList.get( index );
if ( expr2 instanceof RexLocalRef ) {
ref = (RexLocalRef) expr2;
} else {
return ref;
}
}
}
/**
* Adds an expression to the list of common expressions, and returns a reference to the expression. <b>DOES NOT CHECK WHETHER THE EXPRESSION ALREADY EXISTS</b>.
*
* @param expr Expression
* @return Reference to expression
*/
public RexLocalRef addExpr( RexNode expr ) {
RexLocalRef ref;
final int index = exprList.size();
exprList.add( expr );
ref = new RexLocalRef( index, expr.getType() );
localRefList.add( ref );
return ref;
}
/**
* Converts the state of the program builder to an immutable program, normalizing in the process.
*
* It is OK to call this method, modify the program specification (by adding projections, and so forth), and call this method again.
*/
public RexProgram getProgram() {
return getProgram( true );
}
/**
* Converts the state of the program builder to an immutable program.
*
* It is OK to call this method, modify the program specification (by adding projections, and so forth), and call this method again.
*
* @param normalize Whether to normalize
*/
public RexProgram getProgram( boolean normalize ) {
assert projectRefList.size() == projectNameList.size();
// Make sure all fields have a name.
generateMissingNames();
AlgDataType outputRowType = computeOutputRowType();
if ( normalize ) {
return create(
rexBuilder,
inputRowType,
exprList,
projectRefList,
conditionRef,
outputRowType,
true )
.getProgram( false );
}
return new RexProgram(
inputRowType,
exprList,
projectRefList,
conditionRef,
outputRowType );
}
private AlgDataType computeOutputRowType() {
return RexUtil.createStructType( rexBuilder.typeFactory, projectRefList, projectNameList, null );
}
private void generateMissingNames() {
int i = -1;
int j = 0;
for ( String projectName : projectNameList ) {
++i;
if ( projectName == null ) {
while ( true ) {
final String candidateName = "$" + j++;
if ( !projectNameList.contains( candidateName ) ) {
projectNameList.set( i, candidateName );
break;
}
}
}
}
}
/**
* Creates a program builder and initializes it from an existing program.
*
* Calling {@link #getProgram()} immediately after creation will return a program equivalent (in terms of external behavior) to the existing program.
*
* The existing program will not be changed. (It cannot: programs are immutable.)
*
* @param program Existing program
* @param rexBuilder Rex builder
* @param normalize Whether to normalize
* @return A program builder initialized with an equivalent program
*/
public static RexProgramBuilder forProgram( RexProgram program, RexBuilder rexBuilder, boolean normalize ) {
assert program.isValid( Litmus.THROW, null );
final AlgDataType inputRowType = program.getInputRowType();
final List<RexLocalRef> projectRefs = program.getProjectList();
final RexLocalRef conditionRef = program.getCondition();
final List<RexNode> exprs = program.getExprList();
final AlgDataType outputRowType = program.getOutputRowType();
return create(
rexBuilder,
inputRowType,
exprs,
projectRefs,
conditionRef,
outputRowType,
normalize,
false );
}
/**
* Creates a program builder with the same contents as a program.
*
* If {@code normalize}, converts the program to canonical form. In canonical form, in addition to the usual constraints:
*
* <ul>
* <li>The first N internal expressions are {@link RexInputRef}s to the N input fields;</li>
* <li>Subsequent internal expressions reference only preceding expressions;</li>
* <li>Arguments to {@link RexCall}s must be {@link RexLocalRef}s (that is, expressions must have maximum depth 1)</li>
* </ul>
*
* there are additional constraints:
*
* <ul>
* <li>Expressions appear in the left-deep order they are needed by the projections and (if present) the condition. Thus, expression N+1 is the leftmost argument (literal or or call) in the expansion of projection #0.</li>
* <li>There are no duplicate expressions</li>
* <li>There are no unused expressions</li>
* </ul>
*
* @param rexBuilder Rex builder
* @param inputRowType Input row type
* @param exprList Common expressions
* @param projectList Projections
* @param condition Condition, or null
* @param outputRowType Output row type
* @param normalize Whether to normalize
* @param simplify Whether to simplify expressions
* @return A program builder
*/
public static RexProgramBuilder create(
RexBuilder rexBuilder,
final AlgDataType inputRowType,
final List<RexNode> exprList,
final List<? extends RexNode> projectList,
final RexNode condition,
final AlgDataType outputRowType,
boolean normalize,
RexSimplify simplify ) {
return new RexProgramBuilder( rexBuilder, inputRowType, exprList, projectList, condition, outputRowType, normalize, simplify );
}
@Deprecated // to be removed before 2.0
public static RexProgramBuilder create( RexBuilder rexBuilder, final AlgDataType inputRowType, final List<RexNode> exprList, final List<? extends RexNode> projectList, final RexNode condition, final AlgDataType outputRowType, boolean normalize, boolean simplify_ ) {
RexSimplify simplify = null;
if ( simplify_ ) {
simplify = new RexSimplify( rexBuilder, AlgOptPredicateList.EMPTY, RexUtil.EXECUTOR );
}
return new RexProgramBuilder( rexBuilder, inputRowType, exprList, projectList, condition, outputRowType, normalize, simplify );
}
@Deprecated // to be removed before 2.0
public static RexProgramBuilder create( RexBuilder rexBuilder, final AlgDataType inputRowType, final List<RexNode> exprList, final List<? extends RexNode> projectList, final RexNode condition, final AlgDataType outputRowType, boolean normalize ) {
return create( rexBuilder, inputRowType, exprList, projectList, condition, outputRowType, normalize, null );
}
/**
* Creates a program builder with the same contents as a program, applying a shuttle first.
*
* TODO: Refactor the above create method in terms of this one.
*
* @param rexBuilder Rex builder
* @param inputRowType Input row type
* @param exprList Common expressions
* @param projectRefList Projections
* @param conditionRef Condition, or null
* @param outputRowType Output row type
* @param shuttle Shuttle to apply to each expression before adding it to the program builder
* @param updateRefs Whether to update references that changes as a result of rewrites made by the shuttle
* @return A program builder
*/
public static RexProgramBuilder create(
RexBuilder rexBuilder,
final AlgDataType inputRowType,
final List<RexNode> exprList,
final List<RexLocalRef> projectRefList,
final RexLocalRef conditionRef,
final AlgDataType outputRowType,
final RexShuttle shuttle,
final boolean updateRefs ) {
final RexProgramBuilder progBuilder = new RexProgramBuilder( inputRowType, rexBuilder );
progBuilder.add( exprList, projectRefList, conditionRef, outputRowType, shuttle, updateRefs );
return progBuilder;
}
/**
* Adds a set of expressions, projections and filters, applying a shuttle first.
*
* @param exprList Common expressions
* @param projectRefList Projections
* @param conditionRef Condition, or null
* @param outputRowType Output row type
* @param shuttle Shuttle to apply to each expression before adding it to the program builder
* @param updateRefs Whether to update references that changes as a result of rewrites made by the shuttle
*/
private void add( List<RexNode> exprList, List<RexLocalRef> projectRefList, RexLocalRef conditionRef, final AlgDataType outputRowType, RexShuttle shuttle, boolean updateRefs ) {
final List<AlgDataTypeField> outFields = outputRowType.getFieldList();
final RexShuttle registerInputShuttle = new RegisterInputShuttle( false );
// For each common expression, first apply the user's shuttle, then register the result.
// REVIEW jpham: if the user shuttle rewrites an input expression, then input references may change
List<RexLocalRef> newRefs = new ArrayList<>( exprList.size() );
RexShuttle refShuttle = new UpdateRefShuttle( newRefs );
int i = 0;
for ( RexNode expr : exprList ) {
RexNode newExpr = expr;
if ( updateRefs ) {
newExpr = expr.accept( refShuttle );
}
newExpr = newExpr.accept( shuttle );
newRefs.add( i++, (RexLocalRef) newExpr.accept( registerInputShuttle ) );
}
i = -1;
for ( RexLocalRef oldRef : projectRefList ) {
++i;
RexLocalRef ref = oldRef;
if ( updateRefs ) {
ref = (RexLocalRef) oldRef.accept( refShuttle );
}
ref = (RexLocalRef) ref.accept( shuttle );
this.projectRefList.add( ref );
final String name = outFields.get( i ).getName();
assert name != null;
projectNameList.add( name );
}
if ( conditionRef != null ) {
if ( updateRefs ) {
conditionRef = (RexLocalRef) conditionRef.accept( refShuttle );
}
conditionRef = (RexLocalRef) conditionRef.accept( shuttle );
addCondition( conditionRef );
}
}
/**
* Merges two programs together, and normalizes the result.
*
* @param topProgram Top program. Its expressions are in terms of the outputs of the bottom program.
* @param bottomProgram Bottom program. Its expressions are in terms of the result fields of the relational expression's input
* @param rexBuilder Rex builder
* @return Merged program
* @see #mergePrograms(RexProgram, RexProgram, RexBuilder, boolean)
*/
public static RexProgram mergePrograms( RexProgram topProgram, RexProgram bottomProgram, RexBuilder rexBuilder ) {
return mergePrograms( topProgram, bottomProgram, rexBuilder, true );
}
/**
* Merges two programs together.
*
* All expressions become common sub-expressions. For example, the query
*
* <blockquote><pre>
* SELECT x + 1 AS p, x + y AS q FROM (
* SELECT a + b AS x, c AS y
* FROM t
* WHERE c = 6)}
* </pre></blockquote>
*
* would be represented as the programs
*
* <blockquote><pre>
* Calc:
* Projects={$2, $3},
* Condition=null,
* Exprs={$0, $1, $0 + 1, $0 + $1})
* Calc(
* Projects={$3, $2},
* Condition={$4}
* Exprs={$0, $1, $2, $0 + $1, $2 = 6}
* </pre></blockquote>
*
* The merged program is
*
* <blockquote><pre>
* Calc(
* Projects={$4, $5}
* Condition=$6
* Exprs={0: $0 // a
* 1: $1 // b
* 2: $2 // c
* 3: ($0 + $1) // x = a + b
* 4: ($3 + 1) // p = x + 1
* 5: ($3 + $2) // q = x + y
* 6: ($2 = 6) // c = 6
* </pre></blockquote>
*
* Another example:
*
* <blockquote><pre>
* SELECT *
* FROM (
* SELECT a + b AS x, c AS y
* FROM t
* WHERE c = 6)
* WHERE x = 5
* </pre></blockquote>
*
* becomes
*
* <blockquote><pre>
* SELECT a + b AS x, c AS y
* FROM t
* WHERE c = 6 AND (a + b) = 5
* </pre></blockquote>
*
* @param topProgram Top program. Its expressions are in terms of the outputs of the bottom program.
* @param bottomProgram Bottom program. Its expressions are in terms of the result fields of the relational expression's input
* @param rexBuilder Rex builder
* @param normalize Whether to convert program to canonical form
* @return Merged program
*/
public static RexProgram mergePrograms( RexProgram topProgram, RexProgram bottomProgram, RexBuilder rexBuilder, boolean normalize ) {
// Initialize a program builder with the same expressions, outputs and condition as the bottom program.
assert bottomProgram.isValid( Litmus.THROW, null );
assert topProgram.isValid( Litmus.THROW, null );
final RexProgramBuilder progBuilder = RexProgramBuilder.forProgram( bottomProgram, rexBuilder, false );
// Drive from the outputs of the top program. Register each expression used as an output.
final List<RexLocalRef> projectRefList = progBuilder.registerProjectsAndCondition( topProgram );
// Switch to the projects needed by the top program. The original projects of the bottom program are no longer needed.
progBuilder.clearProjects();
final AlgDataType outputRowType = topProgram.getOutputRowType();
for ( Pair<RexLocalRef, String> pair : Pair.zip( projectRefList, outputRowType.getFieldNames(), true ) ) {
progBuilder.addProject( pair.left, pair.right );
}
RexProgram mergedProg = progBuilder.getProgram( normalize );
assert mergedProg.isValid( Litmus.THROW, null );
assert mergedProg.getOutputRowType() == topProgram.getOutputRowType();
return mergedProg;
}
private List<RexLocalRef> registerProjectsAndCondition( RexProgram program ) {
final List<RexNode> exprList = program.getExprList();
final List<RexLocalRef> projectRefList = new ArrayList<>();
final RexShuttle shuttle = new RegisterOutputShuttle( exprList );
// For each project, lookup the expr and expand it so it is in terms of bottomCalc's input fields
for ( RexLocalRef topProject : program.getProjectList() ) {
final RexNode topExpr = exprList.get( topProject.getIndex() );
final RexLocalRef expanded = (RexLocalRef) topExpr.accept( shuttle );
// Remember the expr, but don't add to the project list yet.
projectRefList.add( expanded );
}
// Similarly for the condition.
final RexLocalRef topCondition = program.getCondition();
if ( topCondition != null ) {
final RexNode topExpr = exprList.get( topCondition.getIndex() );
final RexLocalRef expanded = (RexLocalRef) topExpr.accept( shuttle );
addCondition( registerInput( expanded ) );
}
return projectRefList;
}
/**
* Removes all project items.
*
* After calling this method, you may need to re-normalize.
*/
public void clearProjects() {
projectRefList.clear();
projectNameList.clear();
}
/**
* Clears the condition.
*
* After calling this method, you may need to re-normalize.
*/
public void clearCondition() {
conditionRef = null;
}
/**
* Adds a project item for every input field.
*
* You cannot call this method if there are other project items.
*/
public void addIdentity() {
assert projectRefList.isEmpty();
for ( AlgDataTypeField field : inputRowType.getFieldList() ) {
addProject(
new RexInputRef( field.getIndex(), field.getType() ),
field.getName() );
}
}
/**
* Creates a reference to a given input field.
*
* @param index Ordinal of input field, must be less than the number of fields in the input type
* @return Reference to input field
*/
public RexLocalRef makeInputRef( int index ) {
final List<AlgDataTypeField> fields = inputRowType.getFieldList();
assert index < fields.size();
final AlgDataTypeField field = fields.get( index );
return new RexLocalRef( index, field.getType() );
}
/**
* Returns the rowtype of the input to the program
*/
public AlgDataType getInputRowType() {
return inputRowType;
}
/**
* Returns the list of project expressions.
*/
public List<RexLocalRef> getProjectList() {
return projectRefList;
}
/**
* Shuttle that visits a tree of {@link RexNode} and registers them in a program.
*/
private abstract class RegisterShuttle extends RexShuttle {
@Override
public RexNode visitCall( RexCall call ) {
final RexNode expr = super.visitCall( call );
return registerInternal( expr, false );
}
@Override
public RexNode visitOver( RexOver over ) {
final RexNode expr = super.visitOver( over );
return registerInternal( expr, false );
}
@Override
public RexNode visitLiteral( RexLiteral literal ) {
final RexNode expr = super.visitLiteral( literal );
return registerInternal( expr, false );
}
@Override
public RexNode visitFieldAccess( RexFieldAccess fieldAccess ) {
final RexNode expr = super.visitFieldAccess( fieldAccess );
return registerInternal( expr, false );
}
@Override
public RexNode visitDynamicParam( RexDynamicParam dynamicParam ) {
final RexNode expr = super.visitDynamicParam( dynamicParam );
return registerInternal( expr, false );
}
@Override
public RexNode visitCorrelVariable( RexCorrelVariable variable ) {
final RexNode expr = super.visitCorrelVariable( variable );
return registerInternal( expr, false );
}
}
/**
* Shuttle which walks over an expression, registering each sub-expression.
* Each {@link RexInputRef} is assumed to refer to an <em>input</em> of the program.
*/
private class RegisterInputShuttle extends RegisterShuttle {
private final boolean valid;
protected RegisterInputShuttle( boolean valid ) {
this.valid = valid;
}
@Override
public RexNode visitInputRef( RexInputRef input ) {
final int index = input.getIndex();
if ( valid ) {
// The expression should already be valid. Check that its index is within bounds.
if ( (index < 0) || (index >= inputRowType.getFieldCount()) ) {
assert false : "RexInputRef index " + index + " out of range 0.." + (inputRowType.getFieldCount() - 1);
}
// Check that the type is consistent with the referenced field. If it is an object type, the rules are different, so skip the check.
assert input.getType().isStruct() || AlgOptUtil.eq(
"type1",
input.getType(),
"type2",
inputRowType.getFieldList().get( index ).getType(),
Litmus.THROW );
}
// Return a reference to the N'th expression, which should be equivalent.
final RexLocalRef ref = localRefList.get( index );
return ref;
}
@Override
public RexNode visitLocalRef( RexLocalRef local ) {
if ( valid ) {
// The expression should already be valid.
final int index = local.getIndex();
assert index >= 0 : index;
assert index < exprList.size() : "index=" + index + ", exprList=" + exprList;
assert AlgOptUtil.eq(
"expr type",
exprList.get( index ).getType(),
"ref type",
local.getType(),
Litmus.THROW );
}
// Resolve the expression to an input.
while ( true ) {
final int index = local.getIndex();
final RexNode expr = exprList.get( index );
if ( expr instanceof RexLocalRef ) {
local = (RexLocalRef) expr;
if ( local.index >= index ) {
throw new AssertionError( "expr " + local + " references later expr " + local.index );
}
} else {
// Add expression to the list, just so that subsequent expressions don't get screwed up. This expression is unused, so will be eliminated soon.
return registerInternal( local, false );
}
}
}
}
/**
* Extension to {@link RegisterInputShuttle} which allows expressions to be in terms of inputs or previous common sub-expressions.
*/
private class RegisterMidputShuttle extends RegisterInputShuttle {
private final List<RexNode> localExprList;
protected RegisterMidputShuttle( boolean valid, List<RexNode> localExprList ) {
super( valid );
this.localExprList = localExprList;
}
@Override
public RexNode visitLocalRef( RexLocalRef local ) {
// Convert a local ref into the common-subexpression it references.
final int index = local.getIndex();
return localExprList.get( index ).accept( this );
}
}
/**
* Shuttle which walks over an expression, registering each sub-expression.
* Each {@link RexInputRef} is assumed to refer to an <em>output</em> of the program.
*/
private class RegisterOutputShuttle extends RegisterShuttle {
private final List<RexNode> localExprList;
RegisterOutputShuttle( List<RexNode> localExprList ) {
super();
this.localExprList = localExprList;
}
@Override
public RexNode visitInputRef( RexInputRef input ) {
// This expression refers to the Nth project column. Lookup that column and find out what common sub-expression IT refers to.
final int index = input.getIndex();
final RexLocalRef local = projectRefList.get( index );
assert AlgOptUtil.eq(
"type1",
local.getType(),
"type2",
input.getType(),
Litmus.THROW );
return local;
}
@Override
public RexNode visitLocalRef( RexLocalRef local ) {
// Convert a local ref into the common-subexpression it references.
final int index = local.getIndex();
return localExprList.get( index ).accept( this );
}
}
/**
* Shuttle which rewires {@link RexLocalRef} using a list of updated references
*/
private class UpdateRefShuttle extends RexShuttle {
private List<RexLocalRef> newRefs;
private UpdateRefShuttle( List<RexLocalRef> newRefs ) {
this.newRefs = newRefs;
}
@Override
public RexNode visitLocalRef( RexLocalRef localRef ) {
return newRefs.get( localRef.getIndex() );
}
}
}
| 37.869261 | 270 | 0.608855 |
e6fc05fc95bc5fc066ec1e7066d1f81ac5f2502f | 2,549 | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.streams.twitter.serializer;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang.NotImplementedException;
import org.apache.streams.data.ActivitySerializer;
import org.apache.streams.exceptions.ActivitySerializerException;
import org.apache.streams.pojo.json.Activity;
import org.apache.streams.twitter.pojo.Tweet;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;
import static org.apache.streams.twitter.serializer.util.TwitterActivityUtil.*;
public class TwitterJsonTweetActivitySerializer implements ActivitySerializer<String>, Serializable {
private static TwitterJsonTweetActivitySerializer instance = new TwitterJsonTweetActivitySerializer();
public static TwitterJsonTweetActivitySerializer getInstance() {
return instance;
}
@Override
public String serializationFormat() {
return null;
}
@Override
public String serialize(Activity deserialized) throws ActivitySerializerException {
throw new NotImplementedException();
}
@Override
public Activity deserialize(String serialized) throws ActivitySerializerException {
ObjectMapper mapper = StreamsTwitterMapper.getInstance();
Tweet tweet = null;
try {
tweet = mapper.readValue(serialized, Tweet.class);
} catch (JsonProcessingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
Activity activity = new Activity();
updateActivity(tweet, activity);
return activity;
}
@Override
public List<Activity> deserializeAll(List<String> serializedList) {
return null;
}
}
| 32.679487 | 106 | 0.739113 |
54b9e7c8218aca949850ead65416d23c7f2d103a | 2,148 | /*
* Copyright 2021 Google LLC
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.gnd.ui.home.mapcontainer;
import static com.google.android.gnd.rx.RxAutoDispose.disposeOnDestroy;
import android.content.Context;
import android.util.AttributeSet;
import androidx.annotation.Nullable;
import com.google.android.gnd.R;
import com.google.android.gnd.databinding.MapMoveFeatureLayoutBinding;
import com.google.android.gnd.ui.common.AbstractView;
import com.google.android.gnd.ui.map.CameraPosition;
import com.google.android.gnd.ui.map.MapAdapter;
import com.google.android.gnd.ui.map.MapProvider;
import dagger.hilt.android.AndroidEntryPoint;
import dagger.hilt.android.WithFragmentBindings;
import javax.inject.Inject;
@WithFragmentBindings
@AndroidEntryPoint
public class FeatureRepositionView extends AbstractView {
private final FeatureRepositionViewModel viewModel;
@Inject MapProvider mapProvider;
public FeatureRepositionView(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
viewModel = getViewModel(FeatureRepositionViewModel.class);
MapMoveFeatureLayoutBinding binding =
(MapMoveFeatureLayoutBinding) inflate(R.layout.map_move_feature_layout);
binding.setViewModel(viewModel);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
mapProvider
.getMapAdapter()
.toFlowable()
.flatMap(MapAdapter::getCameraMovedEvents)
.map(CameraPosition::getTarget)
.onBackpressureLatest()
.as(disposeOnDestroy(getActivity()))
.subscribe(viewModel::onCameraMoved);
}
}
| 34.095238 | 80 | 0.770484 |
705ab693bb0b7bc0d121244ae35b437823cce915 | 19,708 | package wstxtest.vstream;
import javax.xml.stream.*;
import org.codehaus.stax2.*;
import org.codehaus.stax2.validation.*;
/**
* This is a simple base-line "smoke test" that checks that RelaxNG
* validation works at least minimally.
*/
public class TestRelaxNG
extends BaseValidationTest
{
final static String SIMPLE_RNG_SCHEMA =
"<element name='dict' xmlns='http://relaxng.org/ns/structure/1.0'>\n"
+" <oneOrMore>\n"
+" <element name='term'>\n"
+" <attribute name='type' />\n"
+" <optional>\n"
+" <attribute name='extra' />\n"
+" </optional>\n"
+" <element name='word'><text />\n"
+" </element>\n"
+" <element name='description'> <text />\n"
+" </element>\n"
+" </element>\n"
+" </oneOrMore>\n"
+"</element>"
;
/**
* Similar schema, but one that uses namespaces
*/
final static String SIMPLE_RNG_NS_SCHEMA =
"<element xmlns='http://relaxng.org/ns/structure/1.0' name='root'>\n"
+" <zeroOrMore>\n"
+" <element name='ns:leaf' xmlns:ns='http://test'>\n"
+" <optional>\n"
+" <attribute name='attr1' />\n"
+" </optional>\n"
+" <optional>\n"
+" <attribute name='ns:attr2' />\n"
+" </optional>\n"
+" <text />\n"
+" </element>\n"
+" </zeroOrMore>\n"
+"</element>"
;
/**
* Test validation against a simple document valid according
* to a simple RNG schema.
*/
public void testSimpleNonNs()
throws XMLStreamException
{
String XML =
"<?xml version='1.0'?>"
+"<dict>\n"
+" <term type='name'>\n"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+" </term>"
+" <term type='word' extra='123'>\n"
+" <word>fuzzy</word>\n"
+" <description>adjective</description>\n"
+" </term>"
+"</dict>"
;
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_SCHEMA);
XMLStreamReader2 sr = getReader(XML);
sr.validateAgainst(schema);
try {
assertTokenType(START_ELEMENT, sr.next());
assertEquals("dict", sr.getLocalName());
while (sr.hasNext()) {
sr.next();
}
} catch (XMLValidationException vex) {
fail("Did not expect validation exception, got: "+vex);
}
assertTokenType(END_DOCUMENT, sr.getEventType());
}
/**
* This unit test checks for couple of simple validity problems
* against the simple rng schema. It does not use namespaces
* (a separate test is needed for ns handling).
*/
public void testInvalidNonNs()
throws XMLStreamException
{
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_SCHEMA);
// First, wrong root element:
String XML = "<term type='x'>\n"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term>";
verifyRngFailure(XML, schema, "wrong root element",
"is not allowed. Possible tag names are");
// Then, wrong child ordering:
XML = "<dict>\n"
+"<term type='x'>\n"
+" <description>Foo Bar</description>\n"
+" <word>foobar</word>\n"
+"</term></dict>";
verifyRngFailure(XML, schema, "illegal child element ordering",
"tag name \"description\" is not allowed. Possible tag names are");
// Then, missing children:
XML = "<dict>\n"
+"<term type='x'>\n"
+"</term></dict>";
verifyRngFailure(XML, schema, "missing children",
"uncompleted content model. expecting: <word>");
XML = "<dict>\n"
+"<term type='x'>\n"
+"<word>word</word>"
+"</term></dict>";
verifyRngFailure(XML, schema, "incomplete children",
"uncompleted content model. expecting: <description>");
// Then illegal text in non-mixed element
XML = "<dict>\n"
+"<term type='x'>No text allowed here"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term></dict>";
verifyRngFailure(XML, schema, "invalid non-whitespace text",
"Element <term> has non-mixed content specification; can not contain non-white space text");
// missing attribute
XML = "<dict>\n"
+"<term>"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term></dict>";
// Then undeclared attributes
XML = "<dict>\n"
+"<term attr='value' type='x'>"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term></dict>";
verifyRngFailure(XML, schema, "undeclared attribute",
"unexpected attribute \"attr\"");
XML = "<dict>\n"
+"<term type='x'>"
+" <word type='noun'>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term></dict>";
verifyRngFailure(XML, schema, "undeclared attribute",
"unexpected attribute \"type\"");
}
public void testSimpleNs()
throws XMLStreamException
{
String XML = "<root>\n"
+" <myns:leaf xmlns:myns='http://test' attr1='123' />\n"
+" <ns2:leaf xmlns:ns2='http://test' ns2:attr2='123' />\n"
+"</root>"
;
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_NS_SCHEMA);
XMLStreamReader2 sr = getReader(XML);
sr.validateAgainst(schema);
try {
assertTokenType(START_ELEMENT, sr.next());
assertEquals("root", sr.getLocalName());
while (sr.hasNext()) {
sr.next();
}
} catch (XMLValidationException vex) {
fail("Did not expect validation exception, got: "+vex);
}
assertTokenType(END_DOCUMENT, sr.getEventType());
}
/**
* Unit test checks that the namespace matching works as
* expected.
*/
public void testInvalidNs()
throws XMLStreamException
{
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_NS_SCHEMA);
// First, wrong root element:
String XML = "<root xmlns='http://test'>\n"
+"<leaf />\n"
+"</root>";
verifyRngFailure(XML, schema, "wrong root element",
"namespace URI of tag \"root\" is wrong");
// Wrong child namespace
XML = "<root>\n"
+"<leaf xmlns='http://other' />\n"
+"</root>";
verifyRngFailure(XML, schema, "wrong child element namespace",
"namespace URI of tag \"leaf\" is wrong.");
// Wrong attribute namespace
XML = "<root>\n"
+"<ns:leaf xmlns:ns='http://test' ns:attr1='123' />\n"
+"</root>";
verifyRngFailure(XML, schema, "wrong attribute namespace",
"unexpected attribute \"attr1\"");
}
/**
* This unit test verifies that the validation can be stopped
* half-way through processing, so that sub-trees (for example)
* can be validated. In this case, we will verify this functionality
* by trying to validate invalid document up to the point where it
* is (or may) still be valid, stop validation, and then continue
* reading. This should not result in an exception.
*/
public void testSimplePartialNonNs()
throws XMLStreamException
{
String XML =
"<?xml version='1.0'?>"
+"<dict>"
+"<term type='name'><invalid />"
+"</term>"
+"</dict>"
;
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_SCHEMA);
XMLStreamReader2 sr = getReader(XML);
XMLValidator vtor = sr.validateAgainst(schema);
assertTokenType(START_ELEMENT, sr.next());
assertEquals("dict", sr.getLocalName());
assertTokenType(START_ELEMENT, sr.next());
assertEquals("term", sr.getLocalName());
/* So far so good; but here we'd get an exception... so
* let's stop validating
*/
assertSame(vtor, sr.stopValidatingAgainst(schema));
try {
// And should be good to go
assertTokenType(START_ELEMENT, sr.next());
assertEquals("invalid", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("invalid", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("term", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("dict", sr.getLocalName());
assertTokenType(END_DOCUMENT, sr.next());
} catch (XMLValidationException vex) {
fail("Did not expect validation exception after stopping validation, got: "+vex);
}
sr.close();
// And let's do the same, just using the other stopValidatingAgainst method
sr = getReader(XML);
vtor = sr.validateAgainst(schema);
assertTokenType(START_ELEMENT, sr.next());
assertEquals("dict", sr.getLocalName());
assertTokenType(START_ELEMENT, sr.next());
assertEquals("term", sr.getLocalName());
assertSame(vtor, sr.stopValidatingAgainst(vtor));
try {
// And should be good to go
assertTokenType(START_ELEMENT, sr.next());
assertEquals("invalid", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("invalid", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("term", sr.getLocalName());
assertTokenType(END_ELEMENT, sr.next());
assertEquals("dict", sr.getLocalName());
assertTokenType(END_DOCUMENT, sr.next());
} catch (XMLValidationException vex) {
fail("Did not expect validation exception after stopping validation, got: "+vex);
}
sr.close();
}
public void testSimpleEnumAttr()
throws XMLStreamException
{
final String schemaDef =
"<element xmlns='http://relaxng.org/ns/structure/1.0' name='root'>\n"
+" <attribute name='enumAttr'>\n"
+" <choice>\n"
+" <value>value1</value>\n"
+" <value>another</value>\n"
+" <value>42</value>\n"
+" </choice>\n"
+" </attribute>\n"
+"</element>"
;
XMLValidationSchema schema = parseRngSchema(schemaDef);
// First, simple valid document
String XML = "<root enumAttr='another' />";
XMLStreamReader2 sr = getReader(XML);
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
// And then invalid one, with unrecognized value
XML = "<root enumAttr='421' />";
verifyRngFailure(XML, schema, "enum attribute with unknown value",
"attribute \"enumAttr\" has a bad value");
}
/**
* Test case for testing handling ID/IDREF/IDREF attributes, using
* schema datatype library.
*/
public void testSimpleIdAttrs()
throws XMLStreamException
{
final String schemaDef =
"<element xmlns='http://relaxng.org/ns/structure/1.0'"
+" datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes' name='root'>\n"
+" <oneOrMore>\n"
+" <element name='leaf'>\n"
+" <attribute name='id'><data type='ID' /></attribute>\n"
+" <optional>\n"
+" <attribute name='ref'><data type='IDREF' /></attribute>\n"
+" </optional>\n"
+" <optional>\n"
+" <attribute name='refs'><data type='IDREFS' /></attribute>\n"
+" </optional>\n"
+" </element>\n"
+" </oneOrMore>\n"
+"</element>"
;
XMLValidationSchema schema = parseRngSchema(schemaDef);
// First, a simple valid document
String XML = "<root>"
+" <leaf id='first' ref='second' />\n"
+" <leaf id='second' ref='third' />\n"
+" <leaf id='third' refs='first second third' />\n"
+"</root>"
;
XMLStreamReader2 sr = getReader(XML);
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
// Then one with malformed id
XML = "<root><leaf id='123invalidid' /></root>";
verifyRngFailure(XML, schema, "malformed id",
"attribute \"id\" has a bad value");
// Then with malformed IDREF value (would be valid IDREFS)
XML = "<root>"
+" <leaf id='a' ref='a c' />\n"
+" <leaf id='c' />\n"
+"</root>"
;
verifyRngFailure(XML, schema, "malformed id",
"attribute \"ref\" has a bad value");
// And then invalid one, with dangling ref
XML = "<root>"
+" <leaf id='a' ref='second' />\n"
+"</root>"
;
verifyRngFailure(XML, schema, "reference to undefined id",
"Undefined ID");
// and another one with some of refs undefined
XML = "<root>"
+" <leaf refs='this other' id='this' />\n"
+"</root>"
;
verifyRngFailure(XML, schema, "reference to undefined id",
"Undefined ID");
}
public void testSimpleIntAttr()
throws XMLStreamException
{
final String schemaDef =
"<element xmlns='http://relaxng.org/ns/structure/1.0'"
+" datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes' name='root'>\n"
+" <element name='leaf'>\n"
+" <attribute name='nr'><data type='integer' /></attribute>\n"
+" </element>\n"
+"</element>"
;
XMLValidationSchema schema = parseRngSchema(schemaDef);
// First, a simple valid document
XMLStreamReader2 sr = getReader("<root><leaf nr=' 123 ' /></root>");
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
// Then one with invalid element value
verifyRngFailure("<root><leaf nr='12.03' /></root>",
schema, "invalid integer attribute value",
"does not satisfy the \"integer\" type");
// And missing attribute
verifyRngFailure("<root><leaf /></root>",
schema, "missing integer attribute value",
"is missing \"nr\" attribute");
// And then two variations of having empty value
verifyRngFailure("<root><leaf nr=\"\"/></root>",
schema, "missing integer attribute value",
"does not satisfy the \"integer\" type");
verifyRngFailure("<root><leaf nr='\r\n'/></root>",
schema, "missing integer attribute value",
"does not satisfy the \"integer\" type");
}
/**
* Another test, but one that verifies that empty tags do not
* cause problems with validation
*/
public void testSimpleBooleanElem2()
throws XMLStreamException
{
final String schemaDef =
"<element xmlns='http://relaxng.org/ns/structure/1.0'"
+" datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes' name='root'>\n"
+" <element name='leaf1'><text /></element>\n"
+" <element name='leaf2'>\n"
+" <data type='boolean' />\n"
+" </element>\n"
+"</element>"
;
XMLValidationSchema schema = parseRngSchema(schemaDef);
// First, a simple valid document
XMLStreamReader2 sr = getReader("<root><leaf1>abc</leaf1><leaf2>true</leaf2></root>");
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
// Then another valid, but with empty tag for leaf1
sr = getReader("<root><leaf1 /><leaf2>false</leaf2></root>");
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
// And then one more invalid case
verifyRngFailure("<root><leaf1 /><leaf2>true false</leaf2></root>",
schema, "missing boolean element value",
"does not satisfy the \"boolean\" type");
}
/**
* And then a test for validating starting when stream points
* to START_ELEMENT
*/
public void testPartialValidationOk()
throws XMLStreamException
{
/* Hmmh... RelaxNG does define expected root. So need to
* wrap the doc...
*/
String XML =
"<dummy>\n"
+"<dict>\n"
+"<term type='name'>\n"
+" <word>foobar</word>\n"
+" <description>Foo Bar</description>\n"
+"</term></dict>\n"
+"</dummy>"
;
XMLValidationSchema schema = parseRngSchema(SIMPLE_RNG_SCHEMA);
XMLStreamReader2 sr = getReader(XML);
assertTokenType(START_ELEMENT, sr.next());
sr.validateAgainst(schema);
while (sr.next() != END_DOCUMENT) { }
sr.close();
}
/*
//////////////////////////////////////////////////////////////
// Helper methods
//////////////////////////////////////////////////////////////
*/
private XMLStreamReader2 getReader(String contents) throws XMLStreamException
{
XMLInputFactory2 f = getInputFactory();
setValidating(f, false);
return constructStreamReader(f, contents);
}
private void verifyRngFailure(String xml, XMLValidationSchema schema, String failMsg, String failPhrase)
throws XMLStreamException
{
// By default, yes we are strict...
verifyRngFailure(xml, schema, failMsg, failPhrase, true);
}
private void verifyRngFailure(String xml, XMLValidationSchema schema, String failMsg, String failPhrase,
boolean strict)
throws XMLStreamException
{
XMLStreamReader2 sr = getReader(xml);
sr.validateAgainst(schema);
try {
while (sr.hasNext()) {
/*int type =*/ sr.next();
}
fail("Expected validity exception for "+failMsg);
} catch (XMLValidationException vex) {
String origMsg = vex.getMessage();
String msg = (origMsg == null) ? "" : origMsg.toLowerCase();
if (msg.indexOf(failPhrase.toLowerCase()) < 0) {
String actualMsg = "Expected validation exception for "+failMsg+", containing phrase '"+failPhrase+"': got '"+origMsg+"'";
if (strict) {
fail(actualMsg);
}
warn("suppressing failure due to MSV bug, failure: '"+actualMsg+"'");
}
// should get this specific type; not basic stream exception
} catch (XMLStreamException sex) {
fail("Expected XMLValidationException for "+failMsg);
}
}
}
| 36.161468 | 124 | 0.53014 |
23b34ac821dbc1779501d93428a48a1bbe32065a | 2,741 | package com.example.main.view;
import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.example.login.R;
import com.example.main.adapter.ContactAdapter;
import com.example.main.model.ContactDatabase;
import com.example.main.presenter.ContactPresenter;
import com.example.main.presenter.IContactPresenter;
import java.util.ArrayList;
import java.util.List;
public class ContactFragment extends Fragment implements IContactFragment {
private IContactPresenter presenter;
private List<ContactDatabase> databaseList = new ArrayList<>();
private ContactAdapter adapter;
private RecyclerView recyclerView;
private TextView titleView;
public static ContactFragment newInstance(){
ContactFragment fragment = new ContactFragment();
return fragment;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_contact,container,false);
presenter = new ContactPresenter(getContext(),this);
return view;
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
if (ContextCompat.checkSelfPermission(getContext(), Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(getActivity(),new String[] {
Manifest.permission.READ_CONTACTS
},1);
}else {
databaseList = presenter.readContact();
//adapter.notifyDataSetChanged();
}
initView(view);
}
private void initView(View view){
titleView = view.findViewById(R.id.title_view);
recyclerView = view.findViewById(R.id.contact_recycler);
LinearLayoutManager manager = new LinearLayoutManager(view.getContext());
recyclerView.setLayoutManager(manager);
adapter = new ContactAdapter(view.getContext(),databaseList);
recyclerView.setAdapter(adapter);
if (databaseList!=null && databaseList.size() == 0) {
recyclerView.setVisibility(View.GONE);
titleView.setVisibility(View.VISIBLE);
}
}
}
| 34.2625 | 134 | 0.732944 |
5e812d9ab4962b111348f630cbe0c6ae5696a0d2 | 1,711 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
/**
* Reads from a url and discusses exceptions in more depth
*
* @author J. Evan Noynaert
* @since December 2021
*/
public class App {
public static void main(String[] args) {
final String ADDRESS = "https://raw.githubusercontent.com/noynaert/csc346handouts/main/README.md";
ArrayList<String> lines = new ArrayList<String>();
readRemoteAddress(ADDRESS, lines);
printLines(lines);
System.out.println("\nDone!\n");
}
public static void printLines(ArrayList<String> lines) {
int n = lines.size();
System.out.printf("\nPrinting %d lines:\n", n);
for(int i = 0; i<n; i++)
System.out.printf("[%2d] %s\n", i, lines.get(i));
System.out.printf("\nPrinting %d lines:\n", n);
for (String line : lines) {
System.out.printf(">>>%s<<<\n", line);
}
}
private static void readRemoteAddress(String address, ArrayList<String> lines) {
try {
URL url = new URL(address);
InputStreamReader inStream = new InputStreamReader(url.openStream());
BufferedReader input = new BufferedReader(inStream);
String line;
while ( (line = input.readLine()) != null ){
line = line.trim();
if (line.startsWith("#")) {
lines.add(line);
}
}
input.close();
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(1);
// e.printStackTrace();
}
}
}
| 28.04918 | 106 | 0.5564 |
97cdbfd63c29c8e9c33b614b47a51f7a8e1424ac | 5,085 | /**
*
*/
package com.nitobi.jsp.combo;
import javax.servlet.jsp.JspException;
import com.nitobi.jsp.NitobiBodyTag;
/**
* @author mhan
* @jsp.tag name="combobutton"
* description="A tag to output a ntb:ComboButton element"
*
*/
public class ComboButton extends NitobiBodyTag
{
private static final long serialVersionUID = -3643146415495335017L;
private String defaultcssclassname;
private String height;
private String pressedcssclassname;
private String width;
private String onbeforeselectevent;
private String onblurevent;
private String onfocusevent;
private String onloadevent;
private String onselectevent;
private String ontabevent;
public int doStartTag() throws JspException
{
writeComboButtonStartTag();
return SKIP_BODY;
}
public int doEndTag() throws JspException
{
writeComboButtonEndTag();
return EVAL_PAGE;
}
private void writeComboButtonStartTag() throws JspException
{
try
{
pageContext.getOut().print("<ntb:ComboButton ");
writeTagAttributes();
pageContext.getOut().print(">");
}
catch (java.io.IOException e)
{
throw new JspException(e);
}
}
private void writeComboButtonEndTag() throws JspException
{
try
{
pageContext.getOut().print("</ntb:ComboButton>");
}
catch (java.io.IOException e)
{
throw new JspException(e);
}
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The defaultcssclassname attribute"
* @return the defaultcssclassname
*/
public String getDefaultcssclassname() {
return defaultcssclassname;
}
/**
* @param defaultCssClassname the defaultCssClassname to set
*/
public void setDefaultcssclassname(String defaultCssClassname) {
this.defaultcssclassname = defaultCssClassname;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The height attribute"
* @return the height
*/
public String getHeight() {
return height;
}
/**
* @param height the height to set
*/
public void setHeight(String height) {
this.height = height;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The onbeforeselectevent attribute"
* @return the onbeforeselectevent
*/
public String getOnbeforeselectevent() {
return onbeforeselectevent;
}
/**
* @param onbeforeselectevent the onbeforeselectevent to set
*/
public void setOnbeforeselectevent(String onBeforeSelectEvent) {
this.onbeforeselectevent = onBeforeSelectEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The onblurevent attribute"
* @return the onblurevent
*/
public String getOnblurevent() {
return onblurevent;
}
/**
* @param onblurevent the onblurevent to set
*/
public void setOnblurevent(String onBlurEvent) {
this.onblurevent = onBlurEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The onfocusevent attribute"
* @return the onfocusevent
*/
public String getOnfocusevent() {
return onfocusevent;
}
/**
* @param onfocusevent the onfocusevent to set
*/
public void setOnfocusevent(String onFocusEvent) {
this.onfocusevent = onFocusEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The onloadevent attribute"
* @return the onloadevent
*/
public String getOnloadevent() {
return onloadevent;
}
/**
* @param onloadevent the onloadevent to set
*/
public void setOnloadevent(String onLoadEvent) {
this.onloadevent = onLoadEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The onselectevent attribute"
* @return the onselectevent
*/
public String getOnselectevent() {
return onselectevent;
}
/**
* @param onselectevent the onselectevent to set
*/
public void setOnselectevent(String onSelectEvent) {
this.onselectevent = onSelectEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The ontabevent attribute"
* @return the ontabevent
*/
public String getOntabevent() {
return ontabevent;
}
/**
* @param ontabevent the ontabevent to set
*/
public void setOntabevent(String onTabEvent) {
this.ontabevent = onTabEvent;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The pressedcssclassname attribute"
* @return the pressedcssclassname
*/
public String getPressedcssclassname() {
return pressedcssclassname;
}
/**
* @param pressedCssClassname the pressedcssclassname to set
*/
public void setPressedcssclassname(String pressedCssClassname) {
this.pressedcssclassname = pressedCssClassname;
}
/**
* @jsp.attribute required="false"
* rtexprvalue="true"
* description="The width attribute"
* @return the width
*/
public String getWidth() {
return width;
}
/**
* @param width the width to set
*/
public void setWidth(String width) {
this.width = width;
}
}
| 21.455696 | 68 | 0.691642 |
291dce80d331a94fd6ea0cf43e977fce6d1295df | 791 | package com.geekidea.slutheSample.slutheSampleClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
@RequestMapping("/rest/api/")
public class Sample {
private final Logger log = LoggerFactory.getLogger(Sample.class);
@Autowired
RestTemplate restTemlate;
@GetMapping("hello")
public String getHelloMessage(){
log.info("Sample client hello message method");
return restTemlate.getForObject("http://localhost:9411/rest/api/hello", String.class);
}
}
| 31.64 | 88 | 0.811631 |
75f6eb53e91249419e0df93f723e28cc67305e8d | 109 | package io.github.classgraph.test.accepted;
/**
* Impl1.
*/
public class Impl1 implements IfaceSubSub {
}
| 13.625 | 43 | 0.724771 |
857ca0582121ae96a6a84c28b886bb7e63be6f1b | 6,649 | package uk.gov.hmcts.reform.blobrouter.services.storage;
import com.azure.core.util.polling.PollResponse;
import com.azure.core.util.polling.SyncPoller;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.models.BlobCopyInfo;
import com.azure.storage.blob.sas.BlobContainerSasPermission;
import com.azure.storage.blob.sas.BlobServiceSasSignatureValues;
import com.azure.storage.blob.specialized.BlockBlobClient;
import com.google.common.io.ByteStreams;
import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import uk.gov.hmcts.reform.blobrouter.exceptions.BlobStreamingException;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import static org.slf4j.LoggerFactory.getLogger;
import static uk.gov.hmcts.reform.blobrouter.services.storage.RejectedFilesHandler.REJECTED_CONTAINER_SUFFIX;
@Component
public class BlobMover {
private static final Logger logger = getLogger(BlobMover.class);
//upload chunk size in byte in MB
private final int uploadChunkSize;
private final BlobServiceClient storageClient;
public BlobMover(
BlobServiceClient storageClient,
@Value("${upload-chunk-size-in-bytes}") int chunkSizeInBytes
) {
this.storageClient = storageClient;
this.uploadChunkSize = chunkSizeInBytes;
}
public void moveToRejectedContainer(String blobName, String containerName) {
BlockBlobClient sourceBlob = getBlobClient(containerName, blobName);
BlockBlobClient targetBlob = getBlobClient(containerName + REJECTED_CONTAINER_SUFFIX, blobName);
String loggingContext = String.format(
"File name: %s. Source Container: %s. Target Container: %s",
blobName,
sourceBlob.getContainerName(),
targetBlob.getContainerName()
);
if (!sourceBlob.exists()) {
logger.error("File already deleted. {}", loggingContext);
} else {
String sasToken = sourceBlob
.generateSas(
new BlobServiceSasSignatureValues(
OffsetDateTime.of(LocalDateTime.now().plus(5, ChronoUnit.MINUTES), ZoneOffset.UTC),
new BlobContainerSasPermission().setReadPermission(true)
)
);
if (targetBlob.exists()) {
targetBlob.createSnapshot();
}
SyncPoller<BlobCopyInfo, Void> poller = null;
try {
poller = targetBlob
.beginCopy(
sourceBlob.getBlobUrl() + "?" + sasToken,
null,
null,
null,
null,
null,
Duration.ofSeconds(2)
);
PollResponse<BlobCopyInfo> pollResponse = poller
.waitForCompletion(Duration.ofMinutes(5));
logger.info(
"Moved to rejected container done from {}, Poll response: {}, Copy status: {}",
sourceBlob.getBlobUrl(),
pollResponse.getStatus(),
pollResponse.getValue().getCopyStatus()
);
sourceBlob.delete();
logger.info("File successfully moved to rejected container. {}", loggingContext);
} catch (Exception ex) {
logger.error(
"Copy Error to rejected container, for {}",
sourceBlob.getBlobUrl(),
ex
);
if (poller != null) {
try {
targetBlob.abortCopyFromUrl(poller.poll().getValue().getCopyId());
} catch (Exception exc) {
logger.error(
"Abort Copy From Url got Error, for {} to rejected container",
sourceBlob.getBlobUrl(),
exc
);
}
}
throw ex;
}
}
}
public List<String> uploadWithChunks(BlockBlobClient blockBlobClient, InputStream inStream) {
byte[] envelopeData = new byte[uploadChunkSize];
int blockNumber = 0;
List<String> blockList = new ArrayList<>();
long totalSize = 0L;
try {
while (inStream.available() != 0) {
blockNumber++;
String base64BlockId = Base64.getEncoder()
.encodeToString(String.format("%07d", blockNumber).getBytes());
int numBytesRead = inStream.readNBytes(envelopeData, 0, uploadChunkSize);
totalSize += numBytesRead;
InputStream limitedStream;
limitedStream = ByteStreams
.limit(new ByteArrayInputStream(envelopeData), numBytesRead);
blockBlobClient
.stageBlock(base64BlockId, limitedStream, numBytesRead);
blockList.add(base64BlockId);
}
blockBlobClient.commitBlockList(blockList);
logger.info(
"Upload committed to {}, num of block {}, total size {}",
blockBlobClient.getBlobUrl(),
blockList.size(),
FileUtils.byteCountToDisplaySize(totalSize)
);
} catch (Exception ex) {
logger.info("Upload to {}. FAILED", blockBlobClient.getBlobUrl());
//try to clear uncommitted blocks
tryToDelete(blockBlobClient);
throw new BlobStreamingException("Upload by chunk got error", ex);
}
return blockList;
}
private void tryToDelete(BlockBlobClient blockBlobClient) {
try {
blockBlobClient.delete();
} catch (Exception exc) {
logger.error(
"Deleting uncommitted blocks from {} failed",
blockBlobClient.getBlobUrl(),
exc
);
}
}
private BlockBlobClient getBlobClient(String containerName, String blobName) {
return storageClient.getBlobContainerClient(containerName).getBlobClient(blobName).getBlockBlobClient();
}
}
| 38.656977 | 112 | 0.586705 |
f8404f00ab2cd0bb910b0d5c8c4346f2ffcbaf12 | 21,936 | /* AUTO-GENERATED FILE. DO NOT MODIFY.
*
* This class was automatically generated by the
* aapt tool from the resource data it found. It
* should not be modified by hand.
*/
package com.google.android.gms;
public final class R {
public static final class attr {
public static final int adSize = 0x7f010000;
public static final int adSizes = 0x7f010001;
public static final int adUnitId = 0x7f010002;
public static final int ambientEnabled = 0x7f010019;
public static final int appTheme = 0x7f01001a;
public static final int buttonSize = 0x7f010003;
public static final int buyButtonAppearance = 0x7f010021;
public static final int buyButtonHeight = 0x7f01001e;
public static final int buyButtonText = 0x7f010020;
public static final int buyButtonWidth = 0x7f01001f;
public static final int cameraBearing = 0x7f01000a;
public static final int cameraTargetLat = 0x7f01000b;
public static final int cameraTargetLng = 0x7f01000c;
public static final int cameraTilt = 0x7f01000d;
public static final int cameraZoom = 0x7f01000e;
public static final int circleCrop = 0x7f010008;
public static final int colorScheme = 0x7f010004;
public static final int environment = 0x7f01001b;
public static final int fragmentMode = 0x7f01001d;
public static final int fragmentStyle = 0x7f01001c;
public static final int imageAspectRatio = 0x7f010007;
public static final int imageAspectRatioAdjust = 0x7f010006;
public static final int liteMode = 0x7f01000f;
public static final int mapType = 0x7f010009;
public static final int maskedWalletDetailsBackground = 0x7f010024;
public static final int maskedWalletDetailsButtonBackground = 0x7f010026;
public static final int maskedWalletDetailsButtonTextAppearance = 0x7f010025;
public static final int maskedWalletDetailsHeaderTextAppearance = 0x7f010023;
public static final int maskedWalletDetailsLogoImageType = 0x7f010028;
public static final int maskedWalletDetailsLogoTextColor = 0x7f010027;
public static final int maskedWalletDetailsTextAppearance = 0x7f010022;
public static final int scopeUris = 0x7f010005;
public static final int uiCompass = 0x7f010010;
public static final int uiMapToolbar = 0x7f010018;
public static final int uiRotateGestures = 0x7f010011;
public static final int uiScrollGestures = 0x7f010012;
public static final int uiTiltGestures = 0x7f010013;
public static final int uiZoomControls = 0x7f010014;
public static final int uiZoomGestures = 0x7f010015;
public static final int useViewLifecycle = 0x7f010016;
public static final int windowTransitionStyle = 0x7f010029;
public static final int zOrderOnTop = 0x7f010017;
}
public static final class color {
public static final int common_action_bar_splitter = 0x7f080008;
public static final int common_google_signin_btn_text_dark = 0x7f080024;
public static final int common_google_signin_btn_text_dark_default = 0x7f080009;
public static final int common_google_signin_btn_text_dark_disabled = 0x7f08000b;
public static final int common_google_signin_btn_text_dark_focused = 0x7f08000c;
public static final int common_google_signin_btn_text_dark_pressed = 0x7f08000a;
public static final int common_google_signin_btn_text_light = 0x7f080025;
public static final int common_google_signin_btn_text_light_default = 0x7f08000d;
public static final int common_google_signin_btn_text_light_disabled = 0x7f08000f;
public static final int common_google_signin_btn_text_light_focused = 0x7f080010;
public static final int common_google_signin_btn_text_light_pressed = 0x7f08000e;
public static final int common_plus_signin_btn_text_dark = 0x7f080026;
public static final int common_plus_signin_btn_text_dark_default = 0x7f080000;
public static final int common_plus_signin_btn_text_dark_disabled = 0x7f080002;
public static final int common_plus_signin_btn_text_dark_focused = 0x7f080003;
public static final int common_plus_signin_btn_text_dark_pressed = 0x7f080001;
public static final int common_plus_signin_btn_text_light = 0x7f080027;
public static final int common_plus_signin_btn_text_light_default = 0x7f080004;
public static final int common_plus_signin_btn_text_light_disabled = 0x7f080006;
public static final int common_plus_signin_btn_text_light_focused = 0x7f080007;
public static final int common_plus_signin_btn_text_light_pressed = 0x7f080005;
public static final int place_autocomplete_prediction_primary_text = 0x7f080013;
public static final int place_autocomplete_prediction_primary_text_highlight = 0x7f080014;
public static final int place_autocomplete_prediction_secondary_text = 0x7f080015;
public static final int place_autocomplete_search_hint = 0x7f080012;
public static final int place_autocomplete_search_text = 0x7f080011;
public static final int place_autocomplete_separator = 0x7f080016;
public static final int wallet_bright_foreground_disabled_holo_light = 0x7f08001c;
public static final int wallet_bright_foreground_holo_dark = 0x7f080017;
public static final int wallet_bright_foreground_holo_light = 0x7f08001d;
public static final int wallet_dim_foreground_disabled_holo_dark = 0x7f080019;
public static final int wallet_dim_foreground_holo_dark = 0x7f080018;
public static final int wallet_dim_foreground_inverse_disabled_holo_dark = 0x7f08001b;
public static final int wallet_dim_foreground_inverse_holo_dark = 0x7f08001a;
public static final int wallet_highlighted_text_holo_dark = 0x7f080021;
public static final int wallet_highlighted_text_holo_light = 0x7f080020;
public static final int wallet_hint_foreground_holo_dark = 0x7f08001f;
public static final int wallet_hint_foreground_holo_light = 0x7f08001e;
public static final int wallet_holo_blue_light = 0x7f080022;
public static final int wallet_link_text_light = 0x7f080023;
public static final int wallet_primary_text_holo_light = 0x7f080028;
public static final int wallet_secondary_text_holo_dark = 0x7f080029;
}
public static final class dimen {
public static final int place_autocomplete_button_padding = 0x7f090000;
public static final int place_autocomplete_powered_by_google_height = 0x7f090008;
public static final int place_autocomplete_powered_by_google_start = 0x7f090009;
public static final int place_autocomplete_prediction_height = 0x7f090003;
public static final int place_autocomplete_prediction_horizontal_margin = 0x7f090004;
public static final int place_autocomplete_prediction_primary_text = 0x7f090005;
public static final int place_autocomplete_prediction_secondary_text = 0x7f090006;
public static final int place_autocomplete_progress_horizontal_margin = 0x7f090002;
public static final int place_autocomplete_progress_size = 0x7f090001;
public static final int place_autocomplete_separator_start = 0x7f090007;
}
public static final class drawable {
public static final int cast_ic_notification_0 = 0x7f020008;
public static final int cast_ic_notification_1 = 0x7f020009;
public static final int cast_ic_notification_2 = 0x7f02000a;
public static final int cast_ic_notification_connecting = 0x7f02000b;
public static final int cast_ic_notification_on = 0x7f02000c;
public static final int common_full_open_on_phone = 0x7f02000f;
public static final int common_google_signin_btn_icon_dark = 0x7f020010;
public static final int common_google_signin_btn_icon_dark_disabled = 0x7f020011;
public static final int common_google_signin_btn_icon_dark_focused = 0x7f020012;
public static final int common_google_signin_btn_icon_dark_normal = 0x7f020013;
public static final int common_google_signin_btn_icon_dark_pressed = 0x7f020014;
public static final int common_google_signin_btn_icon_light = 0x7f020015;
public static final int common_google_signin_btn_icon_light_disabled = 0x7f020016;
public static final int common_google_signin_btn_icon_light_focused = 0x7f020017;
public static final int common_google_signin_btn_icon_light_normal = 0x7f020018;
public static final int common_google_signin_btn_icon_light_pressed = 0x7f020019;
public static final int common_google_signin_btn_text_dark = 0x7f02001a;
public static final int common_google_signin_btn_text_dark_disabled = 0x7f02001b;
public static final int common_google_signin_btn_text_dark_focused = 0x7f02001c;
public static final int common_google_signin_btn_text_dark_normal = 0x7f02001d;
public static final int common_google_signin_btn_text_dark_pressed = 0x7f02001e;
public static final int common_google_signin_btn_text_light = 0x7f02001f;
public static final int common_google_signin_btn_text_light_disabled = 0x7f020020;
public static final int common_google_signin_btn_text_light_focused = 0x7f020021;
public static final int common_google_signin_btn_text_light_normal = 0x7f020022;
public static final int common_google_signin_btn_text_light_pressed = 0x7f020023;
public static final int common_ic_googleplayservices = 0x7f020024;
public static final int common_plus_signin_btn_icon_dark = 0x7f020025;
public static final int common_plus_signin_btn_icon_dark_disabled = 0x7f020026;
public static final int common_plus_signin_btn_icon_dark_focused = 0x7f020027;
public static final int common_plus_signin_btn_icon_dark_normal = 0x7f020028;
public static final int common_plus_signin_btn_icon_dark_pressed = 0x7f020029;
public static final int common_plus_signin_btn_icon_light = 0x7f02002a;
public static final int common_plus_signin_btn_icon_light_disabled = 0x7f02002b;
public static final int common_plus_signin_btn_icon_light_focused = 0x7f02002c;
public static final int common_plus_signin_btn_icon_light_normal = 0x7f02002d;
public static final int common_plus_signin_btn_icon_light_pressed = 0x7f02002e;
public static final int common_plus_signin_btn_text_dark = 0x7f02002f;
public static final int common_plus_signin_btn_text_dark_disabled = 0x7f020030;
public static final int common_plus_signin_btn_text_dark_focused = 0x7f020031;
public static final int common_plus_signin_btn_text_dark_normal = 0x7f020032;
public static final int common_plus_signin_btn_text_dark_pressed = 0x7f020033;
public static final int common_plus_signin_btn_text_light = 0x7f020034;
public static final int common_plus_signin_btn_text_light_disabled = 0x7f020035;
public static final int common_plus_signin_btn_text_light_focused = 0x7f020036;
public static final int common_plus_signin_btn_text_light_normal = 0x7f020037;
public static final int common_plus_signin_btn_text_light_pressed = 0x7f020038;
public static final int ic_plusone_medium_off_client = 0x7f020042;
public static final int ic_plusone_small_off_client = 0x7f020043;
public static final int ic_plusone_standard_off_client = 0x7f020044;
public static final int ic_plusone_tall_off_client = 0x7f020045;
public static final int places_ic_clear = 0x7f02004d;
public static final int places_ic_search = 0x7f02004e;
public static final int powered_by_google_dark = 0x7f020050;
public static final int powered_by_google_light = 0x7f020051;
}
public static final class id {
public static final int adjust_height = 0x7f070009;
public static final int adjust_width = 0x7f070008;
public static final int android_pay = 0x7f070028;
public static final int android_pay_dark = 0x7f070022;
public static final int android_pay_light = 0x7f070023;
public static final int android_pay_light_with_border = 0x7f070024;
public static final int auto = 0x7f070005;
public static final int book_now = 0x7f07001d;
public static final int buyButton = 0x7f070014;
public static final int buy_now = 0x7f07001c;
public static final int buy_with = 0x7f070018;
public static final int buy_with_google = 0x7f07001b;
public static final int cast_notification_id = 0x7f070006;
public static final int classic = 0x7f070025;
public static final int dark = 0x7f070003;
public static final int donate_with = 0x7f07001a;
public static final int donate_with_google = 0x7f07001e;
public static final int google_wallet_classic = 0x7f07001f;
public static final int google_wallet_grayscale = 0x7f070020;
public static final int google_wallet_monochrome = 0x7f070021;
public static final int grayscale = 0x7f070026;
public static final int holo_dark = 0x7f07000e;
public static final int holo_light = 0x7f07000f;
public static final int hybrid = 0x7f07000d;
public static final int icon_only = 0x7f070002;
public static final int light = 0x7f070004;
public static final int logo_only = 0x7f070019;
public static final int match_parent = 0x7f070016;
public static final int monochrome = 0x7f070027;
public static final int none = 0x7f070007;
public static final int normal = 0x7f07000a;
public static final int place_autocomplete_clear_button = 0x7f07002c;
public static final int place_autocomplete_powered_by_google = 0x7f07002e;
public static final int place_autocomplete_prediction_primary_text = 0x7f070030;
public static final int place_autocomplete_prediction_secondary_text = 0x7f070031;
public static final int place_autocomplete_progress = 0x7f07002f;
public static final int place_autocomplete_search_button = 0x7f07002a;
public static final int place_autocomplete_search_input = 0x7f07002b;
public static final int place_autocomplete_separator = 0x7f07002d;
public static final int production = 0x7f070010;
public static final int sandbox = 0x7f070012;
public static final int satellite = 0x7f07000b;
public static final int selectionDetails = 0x7f070015;
public static final int slide = 0x7f070029;
public static final int standard = 0x7f070000;
public static final int strict_sandbox = 0x7f070013;
public static final int terrain = 0x7f07000c;
public static final int test = 0x7f070011;
public static final int wide = 0x7f070001;
public static final int wrap_content = 0x7f070017;
}
public static final class integer {
public static final int google_play_services_version = 0x7f0a0000;
}
public static final class layout {
public static final int place_autocomplete_fragment = 0x7f030001;
public static final int place_autocomplete_item_powered_by_google = 0x7f030002;
public static final int place_autocomplete_item_prediction = 0x7f030003;
public static final int place_autocomplete_progress = 0x7f030004;
}
public static final class raw {
public static final int gtm_analytics = 0x7f040000;
}
public static final class string {
public static final int accept = 0x7f060002;
public static final int auth_google_play_services_client_facebook_display_name = 0x7f060007;
public static final int auth_google_play_services_client_google_display_name = 0x7f060006;
public static final int cast_notification_connected_message = 0x7f060025;
public static final int cast_notification_connecting_message = 0x7f060024;
public static final int cast_notification_disconnect = 0x7f060026;
public static final int common_google_play_services_api_unavailable_text = 0x7f06001d;
public static final int common_google_play_services_enable_button = 0x7f06000f;
public static final int common_google_play_services_enable_text = 0x7f06000e;
public static final int common_google_play_services_enable_title = 0x7f06000d;
public static final int common_google_play_services_install_button = 0x7f06000c;
public static final int common_google_play_services_install_text_phone = 0x7f06000a;
public static final int common_google_play_services_install_text_tablet = 0x7f06000b;
public static final int common_google_play_services_install_title = 0x7f060009;
public static final int common_google_play_services_invalid_account_text = 0x7f060018;
public static final int common_google_play_services_invalid_account_title = 0x7f060017;
public static final int common_google_play_services_network_error_text = 0x7f060016;
public static final int common_google_play_services_network_error_title = 0x7f060015;
public static final int common_google_play_services_notification_ticker = 0x7f060008;
public static final int common_google_play_services_restricted_profile_text = 0x7f060021;
public static final int common_google_play_services_restricted_profile_title = 0x7f060020;
public static final int common_google_play_services_sign_in_failed_text = 0x7f06001f;
public static final int common_google_play_services_sign_in_failed_title = 0x7f06001e;
public static final int common_google_play_services_unknown_issue = 0x7f060027;
public static final int common_google_play_services_unsupported_text = 0x7f06001a;
public static final int common_google_play_services_unsupported_title = 0x7f060019;
public static final int common_google_play_services_update_button = 0x7f06001b;
public static final int common_google_play_services_update_text = 0x7f060011;
public static final int common_google_play_services_update_title = 0x7f060010;
public static final int common_google_play_services_updating_text = 0x7f060014;
public static final int common_google_play_services_updating_title = 0x7f060013;
public static final int common_google_play_services_wear_update_text = 0x7f060012;
public static final int common_open_on_phone = 0x7f06001c;
public static final int common_signin_button_text = 0x7f060022;
public static final int common_signin_button_text_long = 0x7f060023;
public static final int create_calendar_message = 0x7f060005;
public static final int create_calendar_title = 0x7f060004;
public static final int decline = 0x7f060003;
public static final int place_autocomplete_clear_button = 0x7f060029;
public static final int place_autocomplete_search_hint = 0x7f060028;
public static final int store_picture_message = 0x7f060001;
public static final int store_picture_title = 0x7f060000;
public static final int wallet_buy_button_place_holder = 0x7f06002a;
}
public static final class style {
public static final int Theme_AppInvite_Preview = 0x7f050002;
public static final int Theme_AppInvite_Preview_Base = 0x7f050001;
public static final int Theme_IAPTheme = 0x7f050000;
public static final int WalletFragmentDefaultButtonTextAppearance = 0x7f050005;
public static final int WalletFragmentDefaultDetailsHeaderTextAppearance = 0x7f050004;
public static final int WalletFragmentDefaultDetailsTextAppearance = 0x7f050003;
public static final int WalletFragmentDefaultStyle = 0x7f050006;
}
public static final class styleable {
public static final int[] AdsAttrs = { 0x7f010000, 0x7f010001, 0x7f010002 };
public static final int AdsAttrs_adSize = 0;
public static final int AdsAttrs_adSizes = 1;
public static final int AdsAttrs_adUnitId = 2;
public static final int[] CustomWalletTheme = { 0x7f010029 };
public static final int CustomWalletTheme_windowTransitionStyle = 0;
public static final int[] LoadingImageView = { 0x7f010006, 0x7f010007, 0x7f010008 };
public static final int LoadingImageView_circleCrop = 2;
public static final int LoadingImageView_imageAspectRatio = 1;
public static final int LoadingImageView_imageAspectRatioAdjust = 0;
public static final int[] MapAttrs = { 0x7f010009, 0x7f01000a, 0x7f01000b, 0x7f01000c, 0x7f01000d, 0x7f01000e, 0x7f01000f, 0x7f010010, 0x7f010011, 0x7f010012, 0x7f010013, 0x7f010014, 0x7f010015, 0x7f010016, 0x7f010017, 0x7f010018, 0x7f010019 };
public static final int MapAttrs_ambientEnabled = 16;
public static final int MapAttrs_cameraBearing = 1;
public static final int MapAttrs_cameraTargetLat = 2;
public static final int MapAttrs_cameraTargetLng = 3;
public static final int MapAttrs_cameraTilt = 4;
public static final int MapAttrs_cameraZoom = 5;
public static final int MapAttrs_liteMode = 6;
public static final int MapAttrs_mapType = 0;
public static final int MapAttrs_uiCompass = 7;
public static final int MapAttrs_uiMapToolbar = 15;
public static final int MapAttrs_uiRotateGestures = 8;
public static final int MapAttrs_uiScrollGestures = 9;
public static final int MapAttrs_uiTiltGestures = 10;
public static final int MapAttrs_uiZoomControls = 11;
public static final int MapAttrs_uiZoomGestures = 12;
public static final int MapAttrs_useViewLifecycle = 13;
public static final int MapAttrs_zOrderOnTop = 14;
public static final int[] SignInButton = { 0x7f010003, 0x7f010004, 0x7f010005 };
public static final int SignInButton_buttonSize = 0;
public static final int SignInButton_colorScheme = 1;
public static final int SignInButton_scopeUris = 2;
public static final int[] WalletFragmentOptions = { 0x7f01001a, 0x7f01001b, 0x7f01001c, 0x7f01001d };
public static final int WalletFragmentOptions_appTheme = 0;
public static final int WalletFragmentOptions_environment = 1;
public static final int WalletFragmentOptions_fragmentMode = 3;
public static final int WalletFragmentOptions_fragmentStyle = 2;
public static final int[] WalletFragmentStyle = { 0x7f01001e, 0x7f01001f, 0x7f010020, 0x7f010021, 0x7f010022, 0x7f010023, 0x7f010024, 0x7f010025, 0x7f010026, 0x7f010027, 0x7f010028 };
public static final int WalletFragmentStyle_buyButtonAppearance = 3;
public static final int WalletFragmentStyle_buyButtonHeight = 0;
public static final int WalletFragmentStyle_buyButtonText = 2;
public static final int WalletFragmentStyle_buyButtonWidth = 1;
public static final int WalletFragmentStyle_maskedWalletDetailsBackground = 6;
public static final int WalletFragmentStyle_maskedWalletDetailsButtonBackground = 8;
public static final int WalletFragmentStyle_maskedWalletDetailsButtonTextAppearance = 7;
public static final int WalletFragmentStyle_maskedWalletDetailsHeaderTextAppearance = 5;
public static final int WalletFragmentStyle_maskedWalletDetailsLogoImageType = 10;
public static final int WalletFragmentStyle_maskedWalletDetailsLogoTextColor = 9;
public static final int WalletFragmentStyle_maskedWalletDetailsTextAppearance = 4;
}
}
| 65.091988 | 246 | 0.833835 |
5b701fa08f9c28600b2d26b1af886454705c082b | 788 | package com.chamabem.util;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlRootElement;
import org.codehaus.jackson.map.annotate.JsonSerialize;
@XmlRootElement
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class ValidationResponse {
List<Validation> validationItems = new ArrayList<Validation>();
private String message;
public void add(Validation validation) {
validationItems.add(validation);
}
public List<Validation> getValidationItems() {
return validationItems;
}
public void setValidationItems(List<Validation> validationItems) {
this.validationItems = validationItems;
}
public void setMessage(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
}
| 20.205128 | 67 | 0.779188 |
a2906adf30a5a518c1d4e3f486471f505c719721 | 873 | import java.lang.Math;
import java.util.ArrayList;
class Boundary
{
double indexRefraction;
Math_Vector vec;
double b1;
double b2;
double b3;
double c1;
double c2;
double c3;
public Boundary(Math_Vector Vec, double IndexOfRefraction, double B1, double B2, double B3,
double C1, double C2, double C3)
{
vec = Vec;
indexRefraction = IndexOfRefraction;
b1 = B1; b2 = B2; b3 = B3;
c1 = C1; c2 = C2; C3 = c3;
}
public double Sellmeier(double wavelength)
{
double w2 = wavelength * wavelength;
return Math.sqrt(1 + (b1*w2)/(w2-c1) + (b2*w2)/(w2-c2) + (b3*w2)/(w2-c3));
}
public double angleOfRefraction(Ray light, double iRefract)
{
double theta2 = Math.abs(Math.asin(light.iRefract/iRefract*light.vec.angleOfIncidence(vec)));
if(light.vec.slope >= 0.0)
return theta2;
else
return 2*Math.PI - theta2;
}
}
| 19.4 | 95 | 0.664376 |
0e092dcdc3f9d9b1bbc7156b194554cf2b983ced | 1,246 | /**
*
*/
package com.jchatting.server.thread;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import com.jchatting.db.DbHanddle;
import com.jchatting.db.bean.Friend;
import com.jchatting.pack.DataPackage;
import com.jchatting.server.util.ClientPool;
import com.jchatting.server.util.ServerMsgUtil;
/**
* @author Xewee.Zhiwei.Wang
* @version 2011-10-2 上午11:10:51
*/
public class OnlineTipThread extends Thread {
private String account;
private Map<String, Friend> friendMap;
public OnlineTipThread(String account) {
this.account = account;
init();
}
private void init() {
friendMap = new DbHanddle().getFriendMap(account);
}
/* (non-Javadoc)
* @see java.lang.Thread#run()
*/
@Override
public void run() {
// TODO Auto-generated method stub
Iterator<String> keyIterator = friendMap.keySet().iterator();
String key;
while (keyIterator.hasNext()) {
key = keyIterator.next();
try {
if (ClientPool.getClient(key) != null) {
ServerMsgUtil.sendMsg(DataPackage.CLIENT_ON, account, key, "");
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
| 21.482759 | 69 | 0.662119 |
69dd420d675d570b61269f20835df251266122f3 | 1,375 | /*
* Copyright 2021 https://github.com/hukacode/huka-common
*
* 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.hukacode.common.usecase;
import javax.validation.ConstraintViolationException;
import javax.validation.Validation;
public abstract class AbstractUseCaseHandler<I, O> implements UseCase<I, O> {
@Override
public O execute(I input) {
if (input == null) {
throw new ValidationException("Input must be not null");
}
var factory = Validation.buildDefaultValidatorFactory();
var validator = factory.getValidator();
var violations = validator.validate(input);
if (!violations.isEmpty()) {
throw new ConstraintViolationException(violations);
}
checkPrerequisite(input);
return business(input);
}
public abstract void checkPrerequisite(I input);
public abstract O business(I input);
}
| 31.25 | 77 | 0.733091 |
1a577098894f0720095a48f7a0979ce281138901 | 2,385 | /*
* Copyright (C) 2015 Sebastian Daschner, sebastian-daschner.com
*
* 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/LICENSE2.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.github.mibo.jaxrsdoc.model.rest;
import java.util.HashSet;
import java.util.Set;
/**
* Represents a response containing meta information which is sent for a specific status code.
*
* @author Sebastian Daschner
*/
public class Response {
private final Set<String> headers = new HashSet<>();
private final TypeIdentifier responseBody;
private final String description;
public Response() {
this(null,null);
}
public Response(final TypeIdentifier responseBody) {
this.responseBody = responseBody;
this.description = null;
}
public Response(TypeIdentifier responseBody, String description) {
this.responseBody = responseBody;
this.description = description;
}
public Set<String> getHeaders() {
return headers;
}
public TypeIdentifier getResponseBody() {
return responseBody;
}
public String getDescription() {
return description;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Response response = (Response) o;
if (!headers.equals(response.headers)) return false;
return !(responseBody != null ? !responseBody.equals(response.responseBody) : response.responseBody != null);
}
@Override
public int hashCode() {
int result = headers.hashCode();
result = 31 * result + (responseBody != null ? responseBody.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "Response{" +
"headers=" + headers +
", responseBody=" + responseBody +
'}';
}
}
| 27.732558 | 117 | 0.65283 |
2b73278f4a3c02135ac05a6a9854dbf9fc6347f6 | 2,112 | package org.functions.Bukkit.API;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.functions.Bukkit.Main.Functions;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.UUID;
public class SpeedPerSeconds {
List<Long> speed = new ArrayList<>();
//List<Location> speeds = new ArrayList<>();
LinkedHashMap<Long,Location> speeds = new LinkedHashMap<>();
ArrayList<Location> listPos = new ArrayList<>();
UUID uuid;
int max;
double sp = 0.0D;
public SpeedPerSeconds(UUID uuid) {
this.uuid = uuid;
}
private Player getPlayer() {
return Functions.instance.getServer().getPlayer(uuid);
}
public void count() {
speeds.put(System.currentTimeMillis(),getPlayer().getLocation());//speed.add(System.currentTimeMillis());
removeTimeout();
listPos.clear();
speeds.forEach((time,pos)->{
listPos.add(pos);
});
Location pos1 = listPos.get(0);
Location pos2 = listPos.get(listPos.size()-1);
if (pos1.getX() != pos2.getX()) {
sp = Math.max(pos1.getX(),pos2.getX()) - Math.min(pos1.getX(),pos2.getX());
}
if (pos1.getY() != pos2.getY()) {
if (sp == 0) {
sp = sp * Math.max(pos1.getY(),pos2.getY()) - Math.min(pos1.getY(),pos2.getY());
}
}
if (pos1.getZ() != pos2.getZ()) {
if (sp == 0) {
sp = sp * Math.max(pos1.getZ(),pos2.getZ()) - Math.min(pos1.getZ(),pos2.getZ());
}
}
}
public void removeTimeout() {
speeds.forEach((e,l)->{
if ((System.currentTimeMillis() - e) > 1000L) {
speeds.remove(e);
}
});
}
public void reset() {
speeds.clear();
max = 0;
}
public void resetMax() {
removeTimeout();
max = 0;
}
public int getMaxSPS() {
removeTimeout();
return max;
}
public double getCountSPS() {
removeTimeout();
return sp;
}
}
| 28.16 | 113 | 0.546402 |
653c97f174a1f1df21012d6b5d2eb16c59230ce3 | 2,573 | package net.de1mos.jbox.webclient.controllers;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import net.de1mos.jbox.api.client.vk.VKMusicTrack;
import net.de1mos.jbox.api.client.vk.VkApiClient;
import net.de1mos.jbox.api.client.vk.core.VKAuthToken;
import net.de1mos.jbox.api.client.vk.core.VKUser;
import net.de1mos.jbox.webclient.viewmodels.Song;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
@Autowired
private VkApiClient apiClient;
private final static String[] vkApiScope = {"audio"};
@RequestMapping("/hello")
public String hello(HttpServletRequest request,
ModelMap model) {
HttpSession session = request.getSession();
VKUser vk = (VKUser) session.getAttribute("VK_USER");
model.addAttribute("VKUser", vk);
System.out.println(vk);
return "hello";
}
@RequestMapping("/searchAudio")
public String searchAudio(HttpServletRequest request,
ModelMap model) {
HttpSession session = request.getSession();
VKUser vk = (VKUser) session.getAttribute("VK_USER");
String query = (String) request.getParameter("searchQuery");
ArrayList<VKMusicTrack> musicList = apiClient.searchMusic(query, vk);
model.addAttribute("musicList", musicList);
model.addAttribute("VKUser", vk);
return "hello";
}
@RequestMapping("/vk/sign")
public String vksign(HttpServletRequest request) {
String code = request.getParameter("code");
if (code!=null)
{
VKAuthToken token = apiClient.getOAuthToken(code);
VKUser user = apiClient.getCurrentVKUserInfo(token);
request.getSession().setAttribute("VK_USER", user);
return "redirect:/hello";
}
else
{
return "redirect:"+apiClient.getAuthURL(vkApiScope);
}
}
@RequestMapping("/song")
@ResponseBody
public Song getSimpleSong() {
return new Song("song title", "song artist");
}
@RequestMapping("/play")
public OutputStream play() throws Exception {
FileInputStream stream = new FileInputStream("/home/denis/song.mp3");
AudioInputStream audioStream = AudioSystem.getAudioInputStream(stream);
return null;
}
}
| 25.22549 | 73 | 0.748931 |
6102f91a36f869a6102de43455ede579aa2f44e9 | 4,977 | package com.andedit.badtrucks.world;
import static com.badlogic.gdx.math.Interpolation.smooth;
import static com.badlogic.gdx.math.MathUtils.floor;
import static com.badlogic.gdx.math.MathUtils.clamp;
import java.util.Random;
import com.andedit.badtrucks.chunk.Chunk;
import com.andedit.badtrucks.chunk.ChunkStatic;
import com.andedit.badtrucks.mesh.verts.TerrainStatic;
import com.andedit.badtrucks.mesh.verts.TerrainStream;
import com.andedit.badtrucks.utils.Camera;
import com.andedit.badtrucks.utils.FastNoise;
import com.badlogic.gdx.graphics.glutils.IndexBufferObject;
import com.badlogic.gdx.graphics.glutils.IndexData;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Plane;
import com.badlogic.gdx.math.Quaternion;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Disposable;
public class World implements Disposable
{
/** The size of the chunks */
public static final int SIZE = 16;
public static final int LENGTH = SIZE*Chunk.SIZE;
public static final int MASK = SIZE-1;
public static final int MASKLEN = LENGTH-1;
public final Chunk[][] chunks;
public final float[][] map;
public final IndexData indices;
public final boolean isEditor;
public World(boolean noise) {
this(noise, false);
}
protected World(boolean noise, boolean isEditor) {
this.chunks = new Chunk[SIZE][SIZE];
this.map = new float[LENGTH][LENGTH];
this.isEditor = isEditor;
if (noise) {
final Random rand = MathUtils.random;
final int
seed1 = rand.nextInt(),
seed2 = rand.nextInt(),
seed3 = rand.nextInt();
for (int x = 0; x < LENGTH; x++)
for (int z = 0; z < LENGTH; z++) {
float value;
value = FastNoise.getPerlin(seed1, 0.04f*x, 0.04f*z)*8f;
value += FastNoise.getPerlin(seed2, 0.02f*x, 0.02f*z)*16f;
value += FastNoise.getPerlin(seed3, 0.01f*x, 0.01f*z)*32f;
map[x][z] = value;
}
}
if (!isEditor)
for (int x = 0; x < SIZE; x++)
for (int z = 0; z < SIZE; z++) {
chunks[x][z] = new ChunkStatic(this, x, z);
}
final int len = 98304>>1;
final short[] index = new short[len];
for (int i = 0, v = 0; i < len; i += 6, v += 4) {
index[i] = (short)v;
index[i+1] = (short)(v+1);
index[i+2] = (short)(v+2);
index[i+3] = (short)(v+2);
index[i+4] = (short)(v+3);
index[i+5] = (short)v;
}
indices = new IndexBufferObject(true, len);
indices.setIndices(index, 0, len);
}
public void render(Camera cam) {
final Vector3 camPos = cam.position;
final Plane[] planes = cam.frustum.planes;
indices.bind();
if (isEditor) TerrainStream.bind(cam);
else TerrainStatic.bind(cam);
for(int x = 0; x < SIZE; x++)
for(int z = 0; z < SIZE; z++) {
Chunk chunk = chunks[x][z];
if (chunk.frust(planes))
chunk.render(camPos);
}
indices.unbind();
}
/** Get height-map. */
public float getHeight(int x, int z) {
return map[clamp(x, 0, MASKLEN)][clamp(z, 0, MASKLEN)];
}
/** Get height-map. */
public void addHeight(int x, int z, float value) {
if (x < 0 || x >= LENGTH || z < 0 || z >= LENGTH)
return;
map[x][z] += value;
}
/** Get height-map without interpolation. */
public float getHeightRaw(float x, float z) {
final int xInt, zInt;
if ((xInt = floor(x)) < 0 || xInt >= LENGTH || (zInt = floor(z)) < 0 || zInt >= LENGTH)
return 0f;
return map[xInt][zInt];
}
/** Get height-map with smoothstep interpolation. */
public float getHeightSmooth(float x, float z) {
final int xInt = floor(x), zInt = floor(z);
return smooth.apply(smooth.apply(getHeight(xInt, zInt ), getHeight(xInt+1, zInt ), x - xInt),
smooth.apply(getHeight(xInt, zInt+1), getHeight(xInt+1, zInt+1), x - xInt), z - zInt);
//interpolate(interpolate(lowerLeft, lowerRight, xFraction), interpolate(upperLeft, upperRight, xFraction), yFraction);
}
/** Get height-map with linear interpolation. */
public float getHeightLerp(float x, float z) {
final int xInt = (int) Math.floor(x), zInt = floor(z);
return MathUtils.lerp(MathUtils.lerp(getHeight(xInt, zInt ), getHeight(xInt+1, zInt ), x - xInt),
MathUtils.lerp(getHeight(xInt, zInt+1), getHeight(xInt+1, zInt+1), x - xInt), z - zInt);
//interpolate(interpolate(lowerLeft, lowerRight, xFraction), interpolate(upperLeft, upperRight, xFraction), yFraction);
}
// calculate light.
private static final Vector3 vec = new Vector3();
private static final Vector3 dir = new Quaternion().setEulerAngles(30, -73, 0).transform(new Vector3(0,0,1));
public float calcLight(int x, int z) {
final float dot;
dot = vec.set(getHeight(x-1, z)-getHeight(x+1, z), 2f,
getHeight(x, z-1)-getHeight(x, z+1)).nor().dot(dir);
return MathUtils.lerp(Math.max(dot, 0.2f), 1.0f, 0.25f);
}
@Override
public void dispose() {
for (int x = 0; x < SIZE; x++)
for (int z = 0; z < SIZE; z++) {
chunks[x][z].dispose();
}
indices.dispose();
}
}
| 31.301887 | 127 | 0.651195 |
bf665b6d521c5a7e8b36d52fbb7a1c54bed6d6c3 | 423 | package org.telegram.android.preview.media;
/**
* Created by ex3ndr on 26.02.14.
*/
public class SmallRawTask extends BaseTask {
private String fileName;
public SmallRawTask(String fileName) {
super(true);
this.fileName = fileName;
}
public String getFileName() {
return fileName;
}
@Override
public String getStorageKey() {
return "s:" + fileName;
}
}
| 18.391304 | 44 | 0.626478 |
9c577d617439bc76821f1af862ab228c564b6797 | 5,993 | package rim.util;
/**
* アルファベット半角全角チェック処理.
*/
public class Alphabet {
/** char文字のチェックを行う配列. **/
protected static final byte[] CHECK_CHAR = new byte[65536];
static {
// スペース系は１.
// ドットは２.
// 数字の終端文字は３.
CHECK_CHAR[' '] = 1;
CHECK_CHAR['\t'] = 1;
CHECK_CHAR['\r'] = 1;
CHECK_CHAR['\n'] = 1;
CHECK_CHAR['.'] = 2;
CHECK_CHAR['L'] = 3;
CHECK_CHAR['l'] = 3;
CHECK_CHAR['F'] = 3;
CHECK_CHAR['f'] = 3;
CHECK_CHAR['D'] = 3;
CHECK_CHAR['d'] = 3;
};
/** アルファベットの半角全角変換値. **/
protected static final char[] CHECK_ALPHABET = new char[65536];
static {
int len = CHECK_ALPHABET.length;
for (int i = 0; i < len; i++) {
CHECK_ALPHABET[i] = (char) i;
}
int code = (int) 'a';
int alpha = (int) ('z' - 'a') + 1;
for (int i = 0; i < alpha; i++) {
CHECK_ALPHABET[i + code] = (char) (code + i);
}
int target = (int) 'A';
for (int i = 0; i < alpha; i++) {
CHECK_ALPHABET[i + target] = (char) (code + i);
}
}
/**
* アルファベットの半角全角変換値を取得します.
* @return
*/
public static final char[] getCheckAlphabet() {
return CHECK_ALPHABET;
}
/**
* 英字の大文字小文字を区別せずにチェック.
*
* @param src
* 比較元文字を設定します.
* @param dest
* 比較先文字を設定します.
* @return boolean [true]の場合、一致します.
*/
public static final boolean eq(String src, String dest) {
if (src == null || dest == null) {
return false;
}
int len = src.length();
if (len == dest.length()) {
for (int i = 0; i < len; i++) {
if (CHECK_ALPHABET[src.charAt(i)] != CHECK_ALPHABET[dest.charAt(i)]) {
return false;
}
}
return true;
}
return false;
}
/**
* 英字の大文字小文字を区別せずにチェック.
*
* @param src
* 比較元文字を設定します.
* @param off
* srcのオフセット値を設定します.
* @param len
* srcのlength値を設定します.
* @param dest
* 比較先文字を設定します.
* @return boolean [true]の場合、一致します.
*/
public static final boolean eq(String src, int off, int len, String dest) {
if (src == null || dest == null || len != dest.length()) {
return false;
}
for (int i = 0; i < len; i++) {
if (CHECK_ALPHABET[src.charAt(i + off)] != CHECK_ALPHABET[dest.charAt(i)]) {
return false;
}
}
return true;
}
/**
* 英字の大文字小文字を区別せずにチェック.
*
* @param src
* 比較元文字を設定します.
* @param dests
* 比較先文字を設定します.
* @return int [-1]の場合不一致です.
*/
public static final int eqArray(String src, String... dests) {
int len;
if (src == null || dests == null || (len = dests.length) == 0) {
return -1;
}
int j;
String n;
boolean eq;
int lenJ = src.length();
for(int i = 0; i < len; i ++) {
if (lenJ == (n = dests[i]).length()) {
eq = true;
for (j = 0; j < lenJ; j++) {
if (CHECK_ALPHABET[src.charAt(j)] != CHECK_ALPHABET[n.charAt(j)]) {
eq = false;
break;
}
}
if(eq) {
return i;
}
}
}
return -1;
}
/**
* 英字の大文字小文字を区別しない、バイトチェック.
*
* @param s
* 比較の文字を設定します.
* @param d
* 比較の文字を設定します.
* @return boolean [true]の場合、一致します.
*/
public static final boolean oneEq(char s, char d) {
return CHECK_ALPHABET[s] == CHECK_ALPHABET[d];
}
/**
* 英字の大文字小文字を区別しない、文字indexOf.
*
* @param buf
* 設定対象の文字情報を設定します.
* @param chk
* チェック対象の文字情報を設定します.
* @param off
* 設定対象のオフセット値を設定します.
* @return int マッチする位置が返却されます. [-1]の場合は情報は存在しません.
*/
public static final int indexOf(final String buf, final String chk) {
return indexOf(buf, chk, 0);
}
/**
* 英字の大文字小文字を区別しない、文字indexOf.
*
* @param buf
* 設定対象の文字情報を設定します.
* @param chk
* チェック対象の文字情報を設定します.
* @param off
* 設定対象のオフセット値を設定します.
* @return int マッチする位置が返却されます. [-1]の場合は情報は存在しません.
*/
public static final int indexOf(final String buf, final String chk, final int off) {
final int len = chk.length();
// 単数文字検索.
if (len == 1) {
final int vLen = buf.length();
if(vLen > off) {
int i = off;
final char first = chk.charAt(0);
if (!oneEq(first, buf.charAt(i))) {
while (++i < vLen && !oneEq(first, buf.charAt(i)))
;
if (vLen != i) {
return i;
}
} else {
return i;
}
}
}
// 複数文字検索.
else {
int j, k, next;
final char first = chk.charAt(0);
final int vLen = buf.length() - (len - 1);
for (int i = off; i < vLen; i++) {
if (!oneEq(first, buf.charAt(i))) {
while (++i < vLen && !oneEq(first, buf.charAt(i)))
;
}
if (i < vLen) {
for (next = i + len, j = i + 1, k = 1; j < next && oneEq(buf.charAt(j), chk.charAt(k)); j++, k++)
;
if (j == next) {
return i;
}
}
}
}
return -1;
}
/**
* Hashコード生成.
*
* @param n
* 対象の文字列を設定します.
* @return int ハッシュコードが返却されます.
*/
public static final int hash(String n) {
int ret = 0;
final int len = n.length();
for (int i = 0; i < len; i++) {
ret = 31 * ret + (int) (CHECK_ALPHABET[n.charAt(i)]);
}
return ret;
}
/**
* 小文字変換.
*
* @param s
* 対象の文字列を設定します.
* @return String 変換された情報が返却されます.
*/
public static final String toLowerCase(String s) {
char[] c = s.toCharArray();
int len = c.length;
for (int i = 0; i < len; i++) {
c[i] = CHECK_ALPHABET[c[i]];
}
return new String(c);
}
/**
* 比較処理.
*
* @param s
* 比較の文字を設定します.
* @param d
* 比較の文字を設定します.
* @return int 数字が返却されます. [マイナス]の場合、sのほうが小さい. [プラス]の場合は、sのほうが大きい.
* [0]の場合は、sとdは同一.
*/
public static final int compareTo(String s, String d) {
if (s == d) {
return 0;
} else if (s == null) {
return -1;
} else if (d == null) {
return 1;
}
int n, len, sLen, dLen;
sLen = s.length();
dLen = d.length();
len = (sLen > dLen) ? dLen : sLen;
for (int i = 0; i < len; i++) {
if ((n = CHECK_ALPHABET[s.charAt(i)] - CHECK_ALPHABET[d.charAt(i)]) > 0) {
return 1;
} else if (n < 0) {
return -1;
}
}
if (sLen > dLen) {
return 1;
} else if (sLen < dLen) {
return -1;
}
return 0;
}
}
| 20.881533 | 102 | 0.531954 |
0aedc17cdc617936049e3a209f70556b47537629 | 635 | package net.sourceforge.ondex.ovtk2.ui.popup;
import edu.uci.ics.jung.visualization.VisualizationViewer;
/**
* An interface for menu items that are interested in knowning the currently
* selected edge and its visualization component context. Used with
* PopupVertexEdgeMenuMousePlugin.
*
* @author Dr. Greg M. Bernstein
*/
public interface EdgeMenuListener<V, E> {
/**
* Used to set the edge and visulization component.
*
* @param egde
* E
* @param visComp
* VisualizationViewer<V, E>
*/
public void setEdgeAndView(E egde, VisualizationViewer<V, E> visComp);
}
| 25.4 | 77 | 0.67874 |
0a19f3a9d6b15c157644a56ce39be7239d8c64f7 | 2,265 |
package com.anjiplus.template.gaea.business.modules.dataSource.controller;
import com.anji.plus.gaea.annotation.Permission;
import com.anji.plus.gaea.bean.ResponseBean;
import com.anji.plus.gaea.curd.controller.GaeaBaseController;
import com.anji.plus.gaea.curd.service.GaeaBaseService;
import com.anjiplus.template.gaea.business.modules.dataSource.controller.dto.DataSourceDto;
import com.anjiplus.template.gaea.business.modules.dataSource.controller.param.ConnectionParam;
import com.anjiplus.template.gaea.business.modules.dataSource.controller.param.DataSourceParam;
import com.anjiplus.template.gaea.business.modules.dataSource.dao.entity.DataSource;
import com.anjiplus.template.gaea.business.modules.dataSource.service.DataSourceService;
import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* @desc 数据源 controller
* @website https://gitee.com/anji-plus/gaea
* @author Raod
* @date 2021-03-18 12:09:57.728203200
**/
@RestController
@Api(tags = "数据源管理")
@Permission(code = "datasourceManage", name = "数据源管理")
@RequestMapping("/dataSource")
public class DataSourceController extends GaeaBaseController<DataSourceParam, DataSource, DataSourceDto> {
@Autowired
private DataSourceService dataSourceService;
@Override
public GaeaBaseService<DataSourceParam, DataSource> getService() {
return dataSourceService;
}
@Override
public DataSource getEntity() {
return new DataSource();
}
@Override
public DataSourceDto getDTO() {
return new DataSourceDto();
}
/**
* 获取所有数据源
* @return
*/
@GetMapping("/queryAllDataSource")
public ResponseBean queryAllDataSource() {
return responseSuccessWithData(dataSourceService.queryAllDataSource());
}
/**
* 测试 连接
* @param connectionParam
* @return
*/
@Permission( code = "query", name = "测试数据源")
@PostMapping("/testConnection")
public ResponseBean testConnection(@Validated @RequestBody ConnectionParam connectionParam) {
return responseSuccessWithData(dataSourceService.testConnection(connectionParam));
}
}
| 32.826087 | 106 | 0.756733 |
e3731536be1aab983448082ae3fea19df1093553 | 6,596 | package cropcert.entities.service;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.Response;
import org.json.JSONException;
import org.json.JSONObject;
import org.pac4j.core.profile.CommonProfile;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.inject.Inject;
import com.sun.jersey.core.header.FormDataContentDisposition;
import cropcert.entities.api.CollectionCenterApi;
import cropcert.entities.api.CooperativeApi;
import cropcert.entities.dao.UserDao;
import cropcert.entities.filter.Permissions;
import cropcert.entities.model.CollectionCenter;
import cropcert.entities.model.CollectionCenterPerson;
import cropcert.entities.model.Cooperative;
import cropcert.entities.model.CooperativePerson;
import cropcert.entities.model.ICSManager;
import cropcert.entities.model.Inspector;
import cropcert.entities.model.UnionPerson;
import cropcert.entities.model.User;
import cropcert.entities.util.AuthUtility;
import cropcert.entities.util.MessageDigestPasswordEncoder;
public class UserService extends AbstractService<User> {
public final static String rootPath = System.getProperty("user.home") + File.separatorChar + "cropcert-image";
@Inject
private ObjectMapper objectMappper;
@Inject
private MessageDigestPasswordEncoder passwordEncoder;
@Inject
private CooperativeApi cooperativeApi;
@Inject
private CollectionCenterApi collectionCenterApi;
private static Set<String> defaultPermissions;
static {
defaultPermissions = new HashSet<String>();
defaultPermissions.add(Permissions.DEFAULT);
}
@Inject
public UserService(UserDao userDao) {
super(userDao);
}
public User save(String jsonString) throws JsonParseException, JsonMappingException, IOException, JSONException {
User user = objectMappper.readValue(jsonString, User.class);
JSONObject jsonObject = new JSONObject(jsonString);
String password = jsonObject.getString("password");
password = passwordEncoder.encodePassword(password, null);
user.setPassword(password);
user.setPermissions(defaultPermissions);
return save(user);
}
public User updatePassword(HttpServletRequest request, String password) {
CommonProfile profile = AuthUtility.getCurrentUser(request);
User user = findById(Long.parseLong(profile.getId()));
password = passwordEncoder.encodePassword(password, null);
user.setPassword(password);
return update(user);
}
public User getByEmail(String email) {
return findByPropertyWithCondtion("email", email, "=");
}
public User getByUserName(String userName) {
return findByPropertyWithCondtion("userName", userName, "=");
}
public User findByPropertyWithCondtion(String property, String value, String condition) {
return dao.findByPropertyWithCondition(property, value, condition);
}
public Map<String, Object> getMyData(HttpServletRequest request) {
//CommonProfile profile = AuthUtility.getCurrentUser(request);
//User user = findById(Long.parseLong(profile.getId()));
User user = findById(Long.parseLong("1"));
Map<String, Object> myData = new HashMap<String, Object>();
myData.put("user", user);
// Insert data specific to user
myData.put("ccCode", -1);
myData.put("coCode", -1);
myData.put("unionCode", -1);
if (user instanceof UnionPerson) {
myData.put("unionCode", ((UnionPerson) user).getUnionCode());
} else if (user instanceof Inspector) {
myData.put("unionCode", ((Inspector) user).getUnionCode());
} else if (user instanceof ICSManager) {
myData.put("unionCode", ((ICSManager) user).getUnionCode());
} else if (user instanceof CooperativePerson) {
CooperativePerson coPerson = (CooperativePerson) user;
int coCode = coPerson.getCoCode();
myData.put("coCode", coPerson.getCoCode());
Response coResponse = cooperativeApi.findByCode(request, (long) coCode);
if (coResponse.getEntity() != null) {
Cooperative cooperative = (Cooperative) coResponse.getEntity();
myData.put("unionCode", cooperative.getUnionCode());
}
} else if (user instanceof CollectionCenterPerson) {
CollectionCenterPerson ccPerson = (CollectionCenterPerson) user;
int ccCode = ccPerson.getCcCode();
myData.put("ccCode", ccCode);
Response ccResponse = collectionCenterApi.findByCode(request, (long) ccCode);
if (ccResponse.getEntity() != null) {
CollectionCenter collectionCenter = (CollectionCenter) ccResponse.getEntity();
Long coCode = collectionCenter.getCoCode();
myData.put("coCode", coCode);
Response coResponse = cooperativeApi.findByCode(request, (long) coCode);
if (coResponse.getEntity() != null) {
Cooperative cooperative = (Cooperative) coResponse.getEntity();
myData.put("unionCode", cooperative.getUnionCode());
}
}
}
return myData;
}
public User uploadSignature(HttpServletRequest request, InputStream inputStream,
FormDataContentDisposition fileDetails) throws IOException {
CommonProfile profile = AuthUtility.getCommonProfile(request);
Long id = Long.parseLong(profile.getId());
User user = findById(id);
String sign = addImage(inputStream, fileDetails, request);
user.setSign(sign);
update(user);
return user;
}
public String addImage(InputStream inputStream, FormDataContentDisposition fileDetails,
HttpServletRequest request) {
String fileName = fileDetails.getFileName();
UUID uuid = UUID.randomUUID();
String dirPath = rootPath + File.separator + uuid.toString();
File dir = new File(dirPath);
if(!dir.exists()) {
dir.mkdir();
}
String fileLocation = dirPath + File.separatorChar + fileName;
boolean uploaded = writeToFile(inputStream, fileLocation);
if (uploaded) {
return request.getRequestURI() + "/" + uuid + "/" + fileName;
} else {
return null;
}
}
private boolean writeToFile(InputStream inputStream, String fileLocation) {
try {
OutputStream out = new FileOutputStream(new File(fileLocation));
int read = 0;
byte[] bytes = new byte[1024];
out = new FileOutputStream(new File(fileLocation));
while ((read = inputStream.read(bytes)) != -1) {
out.write(bytes, 0, read);
}
out.flush();
out.close();
return true;
} catch (IOException e) {
e.printStackTrace();
}
return false;
}
}
| 31.559809 | 114 | 0.754851 |
751f62df5ea2075e4cf89f54fd8638cf06ba24c9 | 403 | package org.apache.commons.mail;
import org.apache.commons.mail.Email;
import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.SimpleEmail;
import junit.framework.TestCase;
public class simpleTest extends TestCase {
public void testsimple() {
System.out.println("This is a message from the simple test.");
String result = "oneTwo";
assertEquals("oneTwo", result);
}
}
| 22.388889 | 64 | 0.764268 |
33b0fa3b0005e4404128894bd953983dfd545e48 | 3,152 | package edu.ucsb.courses.documents;
import java.util.List;
import java.util.Objects;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CoursePage {
private final static Logger logger = LoggerFactory.getLogger(CoursePage.class);
private int pageNumber;
private int pageSize;
private int total;
List<Course> classes;
public CoursePage() {
}
public CoursePage(int pageNumber, int pageSize, int total, List<Course> classes) {
this.pageNumber = pageNumber;
this.pageSize = pageSize;
this.total = total;
this.classes = classes;
}
public int getPageNumber() {
return this.pageNumber;
}
public void setPageNumber(int pageNumber) {
this.pageNumber = pageNumber;
}
public int getPageSize() {
return this.pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotal() {
return this.total;
}
public void setTotal(int total) {
this.total = total;
}
public List<Course> getClasses() {
return this.classes;
}
public void setClasses(List<Course> classes) {
this.classes = classes;
}
@Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof CoursePage)) {
return false;
}
CoursePage cp = (CoursePage) o;
EqualsBuilder builder = new EqualsBuilder();
builder.append(pageNumber, cp.getPageNumber()).append(pageSize, cp.getPageSize()).append(total,cp.getTotal()).append(classes,cp.getClasses());
return builder.build();
}
@Override
public int hashCode() {
return Objects.hash(pageNumber, pageSize, total, classes);
}
@Override
public String toString() {
return "{" + " pageNumber='" + getPageNumber() + "'" + ", pageSize='" + getPageSize() + "'" + ", total='"
+ getTotal() + "'" + ", classes='" + getClasses() + "'" + "}";
}
/**
* Create a CoursePage object from json representation
*
* @param json String of json returned by API endpoint {@code /classes/search}
* @return a new CoursePage object
* @see <a href=
* "https://developer.ucsb.edu/content/academic-curriculums">https://developer.ucsb.edu/content/academic-curriculums</a>
*/
public static CoursePage fromJSON(String json) {
try {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
CoursePage coursePage = objectMapper.readValue(json, CoursePage.class);
return coursePage;
} catch (JsonProcessingException jpe) {
logger.error("JsonProcessingException:" + jpe);
return null;
}
}
} | 27.172414 | 150 | 0.630076 |
37da76b8639afd058849e1fd25f1710c019cac6f | 492 | package trb1914.rogue.ui;
import processing.core.PImage;
/**
* A tile button makes any tile from the game fit on that button
* @author trb1914
*/
public class TileButton extends IconButton{
/**
* Creates a new TileButton that will resize the provided image to fit on a button
* @param x
* @param y
* @param type
* @param image
*/
public TileButton(int x, int y, ButtonType type, PImage image) {
super(x, y, type, image);
image.resize(8, 8);
off.x = off.y = 4;
}
}
| 20.5 | 83 | 0.670732 |
cfa9311d60daca46542c15c5a8b8acf1e5afc1e9 | 3,752 | package org.jivesoftware.smackx.workgroup.packet;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import org.jitsi.gov.nist.core.Separators;
import org.jitsi.org.xmlpull.v1.XmlPullParser;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.provider.IQProvider;
public class AgentStatusRequest extends IQ {
public static final String ELEMENT_NAME = "agent-status-request";
public static final String NAMESPACE = "http://jabber.org/protocol/workgroup";
/* access modifiers changed from: private */
public Set<Item> agents = new HashSet();
public static class Item {
private String jid;
private String name;
private String type;
public Item(String jid, String type, String name) {
this.jid = jid;
this.type = type;
this.name = name;
}
public String getJID() {
return this.jid;
}
public String getType() {
return this.type;
}
public String getName() {
return this.name;
}
}
public static class Provider implements IQProvider {
public IQ parseIQ(XmlPullParser parser) throws Exception {
AgentStatusRequest statusRequest = new AgentStatusRequest();
if (parser.getEventType() != 2) {
throw new IllegalStateException("Parser not in proper position, or bad XML.");
}
boolean done = false;
while (!done) {
int eventType = parser.next();
if (eventType == 2 && "agent".equals(parser.getName())) {
statusRequest.agents.add(parseAgent(parser));
} else if (eventType == 3 && AgentStatusRequest.ELEMENT_NAME.equals(parser.getName())) {
done = true;
}
}
return statusRequest;
}
private Item parseAgent(XmlPullParser parser) throws Exception {
boolean done = false;
String jid = parser.getAttributeValue("", "jid");
String type = parser.getAttributeValue("", "type");
String name = null;
while (!done) {
int eventType = parser.next();
if (eventType == 2 && "name".equals(parser.getName())) {
name = parser.nextText();
} else if (eventType == 3 && "agent".equals(parser.getName())) {
done = true;
}
}
return new Item(jid, type, name);
}
}
public int getAgentCount() {
return this.agents.size();
}
public Set<Item> getAgents() {
return Collections.unmodifiableSet(this.agents);
}
public String getElementName() {
return ELEMENT_NAME;
}
public String getNamespace() {
return "http://jabber.org/protocol/workgroup";
}
public String getChildElementXML() {
StringBuilder buf = new StringBuilder();
buf.append(Separators.LESS_THAN).append(ELEMENT_NAME).append(" xmlns=\"").append("http://jabber.org/protocol/workgroup").append("\">");
synchronized (this.agents) {
for (Item item : this.agents) {
buf.append("<agent jid=\"").append(item.getJID()).append("\">");
if (item.getName() != null) {
buf.append("<name xmlns=\"http://jivesoftware.com/protocol/workgroup\">");
buf.append(item.getName());
buf.append("</name>");
}
buf.append("</agent>");
}
}
buf.append("</").append(getElementName()).append("> ");
return buf.toString();
}
}
| 34.109091 | 143 | 0.557569 |
395b8e4532ce699eef6d6fc489093e4219419014 | 6,050 | /*
* Copyright 2017 Globus Ltd.
* <p/>
* 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
* <p/>
* http://www.apache.org/licenses/LICENSE-2.0
* <p/>
* 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.globusltd.recyclerview.datasource;
import android.support.annotation.IntRange;
import android.support.annotation.MainThread;
import android.support.annotation.NonNull;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Datasource implementation that uses {@link ArrayList} of the elements as
* the underlying data storage.
*/
@MainThread
public class ListDatasource<E> implements Datasource<E> {
@NonNull
private final List<E> mItems;
@NonNull
private final DatasourceObservable mDatasourceObservable;
public ListDatasource() {
this(Collections.<E>emptyList());
}
public ListDatasource(@NonNull final List<? extends E> items) {
mItems = new ArrayList<>(items);
mDatasourceObservable = new DatasourceObservable();
}
/**
* {@inheritDoc}
*/
@NonNull
@Override
public E get(@IntRange(from = 0) final int position) {
return mItems.get(position);
}
/**
* Adds a data entity to the end.
*
* @param e a data entity
*/
public void add(@NonNull final E e) {
if (mItems.add(e)) {
final int position = mItems.size() - 1;
mDatasourceObservable.notifyItemRangeInserted(position, 1);
}
}
/**
* Adds a data entity to a given position.
*
* @param position an index in the data set.
* @param e a data entity.
*/
public void add(@IntRange(from = 0) final int position, @NonNull final E e) {
mItems.add(position, e);
mDatasourceObservable.notifyItemRangeInserted(position, 1);
}
/**
* Adds all data entities to the end.
*
* @param items a non-null {@link List} of data entities.
*/
public void addAll(@NonNull final List<? extends E> items) {
final int positionStart = mItems.size();
if (mItems.addAll(items)) {
final int itemCount = items.size();
mDatasourceObservable.notifyItemRangeInserted(positionStart, itemCount);
}
}
/**
* Adds all data entities after the specified position.
*
* @param position position at which to insert the first element
* from the specified collection.
* @param items a non-null {@link List} of data entities.
*/
public void addAll(@IntRange(from = 0) final int position,
@NonNull final List<? extends E> items) {
if (mItems.addAll(position, items)) {
final int itemCount = items.size();
mDatasourceObservable.notifyItemRangeInserted(position, itemCount);
}
}
/**
* Moves entity from one position to another.
*
* @param fromPosition an initial index.
* @param toPosition a new index.
*/
public void move(@IntRange(from = 0) final int fromPosition,
@IntRange(from = 0) final int toPosition) {
final E e = mItems.remove(fromPosition);
mItems.add(toPosition, e);
mDatasourceObservable.notifyItemMoved(fromPosition, toPosition);
}
/**
* Replaces the element at the specified position in this list with the
* specified element.
*
* @param position index of the element to replace.
* @param item element to be stored at the specified position.
* @return the element previously at the specified position.
*/
@NonNull
public E set(@IntRange(from = 0) final int position, @NonNull final E item) {
final E e = mItems.set(position, item);
mDatasourceObservable.notifyItemRangeChanged(position, 1, null);
return e;
}
/**
* Removes entity at a given position.
*
* @param position an index in the list of entities.
* @return removed entity.
*/
@NonNull
public E remove(@IntRange(from = 0) final int position) {
final E e = mItems.remove(position);
mDatasourceObservable.notifyItemRangeRemoved(position, 1);
return e;
}
/**
* Removes a range of elements.
*
* @param fromPosition Position of the first item that be removed.
* @param itemCount Number of items removed from the data set.
*/
public void removeRange(@IntRange(from = 0) final int fromPosition,
@IntRange(from = 1) final int itemCount) {
for (int position = fromPosition + itemCount - 1; position >= fromPosition; position--) {
mItems.remove(position);
}
mDatasourceObservable.notifyItemRangeRemoved(fromPosition, itemCount);
}
/**
* Removes all of the elements from this datastore.
* The datastore will be empty after this call returns.
*/
public void clear() {
final int itemCount = mItems.size();
mItems.clear();
mDatasourceObservable.notifyItemRangeRemoved(0, itemCount);
}
/**
* {@inheritDoc}
*/
@Override
public int size() {
return mItems.size();
}
/**
* {@inheritDoc}
*/
@Override
public void registerDatasourceObserver(@NonNull final DatasourceObserver observer) {
mDatasourceObservable.registerObserver(observer);
}
/**
* {@inheritDoc}
*/
@Override
public void unregisterDatasourceObserver(@NonNull final DatasourceObserver observer) {
mDatasourceObservable.unregisterObserver(observer);
}
}
| 30.555556 | 97 | 0.634876 |
82815c5a948c4124c98813dbb53b186b10610e1e | 19,386 | /*
* MIT License
*
* Copyright (c) 2017 Barracks Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package io.barracks.membergateway.manager;
import io.barracks.membergateway.client.DeviceServiceClient;
import io.barracks.membergateway.exception.InvalidOwnerException;
import io.barracks.membergateway.manager.entity.SegmentStatus;
import io.barracks.membergateway.model.Device;
import io.barracks.membergateway.model.DeviceConfiguration;
import io.barracks.membergateway.model.DeviceEvent;
import io.barracks.membergateway.model.Segment;
import io.barracks.membergateway.rest.entity.SegmentsOrder;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.hateoas.PagedResources;
import java.security.SecureRandom;
import java.util.*;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.hamcrest.Matchers.hasItem;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class SegmentManagerTest {
@Mock
private DeviceServiceClient deviceServiceClient;
private SegmentManager segmentManager;
@Before
public void setup() {
this.segmentManager = spy(new SegmentManager(deviceServiceClient));
}
@Test
public void createSegment_shouldCallClientAndEnhanceSegment() {
// Given
final String userId = UUID.randomUUID().toString();
final Segment segment = Segment.builder().name("name").build();
final Segment toCreate = Segment.builder().userId(userId).name(segment.getName()).build();
final Segment expected = Segment.builder().id(UUID.randomUUID().toString()).name("name").userId(userId).active(false).deviceCount(42).build();
doReturn(expected).when(deviceServiceClient).createSegment(toCreate);
doReturn(expected).when(segmentManager).enhanceSegment(expected);
// When
Segment result = segmentManager.createSegment(userId, segment);
// Then
verify(deviceServiceClient).createSegment(toCreate);
verify(segmentManager).enhanceSegment(expected);
assertThat(result).isEqualTo(expected);
}
@Test
public void updateSegment_shouldCallClientAndEnhanceSegment() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final Segment segment = Segment.builder().name("toUpdate").build();
final Segment toUpdate = Segment.builder().userId(userId).name(segment.getName()).build();
final Segment expected = Segment.builder().id(segmentId).name("updated").active(false).deviceCount(42).build();
doReturn(null).when(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
doReturn(expected).when(deviceServiceClient).updateSegment(segmentId, toUpdate);
doReturn(expected).when(segmentManager).enhanceSegment(expected);
// When
Segment result = segmentManager.updateSegment(userId, segmentId, segment);
// Then
verify(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
verify(deviceServiceClient).updateSegment(segmentId, toUpdate);
verify(segmentManager).enhanceSegment(expected);
assertThat(result).isEqualTo(expected);
}
@Test
public void getSegmentForUser_shouldCheckOwnershipAndReturnEnhancedSegments() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final Segment segment = Segment.builder().id(segmentId).name("name").userId(userId).build();
final Segment enhanced = segment.toBuilder().active(true).deviceCount(42).build();
doReturn(segment).when(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
doReturn(enhanced).when(segmentManager).enhanceSegment(segment);
// When
final Segment result = segmentManager.getSegmentForUser(userId, segmentId);
// Then
verify(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
verify(segmentManager).enhanceSegment(segment);
assertThat(result).isEqualTo(enhanced);
}
@Test
public void getSegmentForUser_whenOtherSegment_shouldReturnOtherSegment() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = "other";
final Segment expected = Segment.builder().id(UUID.randomUUID().toString()).build();
doReturn(expected).when(segmentManager).getOtherSegment(userId);
// When
final Segment result = segmentManager.getSegmentForUser(userId, segmentId);
// Then
verify(segmentManager).getOtherSegment(userId);
assertThat(result).isEqualTo(expected);
}
@Test
public void getSegmentsForUser_shouldCallClientAndReturnEnhancedSegments() {
// Given
final String userId = UUID.randomUUID().toString();
final Pageable pageable = new PageRequest(0, 10);
final Segment segment = Segment.builder().id(UUID.randomUUID().toString()).name("name").userId(userId).build();
final Segment enhanced = segment.toBuilder().active(true).deviceCount(42).build();
final PagedResources<Segment> segmentPagedResources = new PagedResources<>(Collections.singleton(segment), new PagedResources.PageMetadata(1, 0, 1));
doReturn(segmentPagedResources).when(deviceServiceClient).getSegments(userId, pageable);
doReturn(Collections.singletonList(enhanced))
.when(segmentManager).enhanceSegments((Collection<Segment>) argThat(hasItem(segment)));
// When
final Page<Segment> result = segmentManager.getSegmentsForUser(userId, pageable);
// Then
verify(deviceServiceClient).getSegments(userId, pageable);
verify(segmentManager).enhanceSegments((Collection<Segment>) argThat(hasItem(segment)));
assertThat(result).hasSize(1).contains(enhanced);
}
@Test
public void getDevicesBySegment_whitSegmentId_shouldCallClientAndReturnEvents() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final Pageable pageable = new PageRequest(0, 10);
final DeviceEvent event = DeviceEvent.builder().unitId(UUID.randomUUID().toString()).versionId(UUID.randomUUID().toString()).build();
final DeviceConfiguration configuration = DeviceConfiguration.builder().build();
final Device device = Device.builder().lastEvent(event).configuration(configuration).unitId(UUID.randomUUID().toString()).build();
doReturn(null).when(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
doReturn(new PagedResources<>(Collections.singletonList(device), new PagedResources.PageMetadata(1, 0, 1)))
.when(deviceServiceClient).getDevicesBySegment(userId, segmentId, pageable);
// When
Page<Device> result = segmentManager.getDevicesBySegment(userId, segmentId, pageable);
// Then
verify(segmentManager).getSegmentAndCheckOwnership(userId, segmentId);
verify(deviceServiceClient).getDevicesBySegment(userId, segmentId, pageable);
assertThat(result).hasSize(1).contains(device);
}
@Test
public void getDeviceBySegment_forOtherSegment_shouldCallClientAndReturnEvents() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = "other";
final Pageable pageable = new PageRequest(0, 10);
final DeviceEvent event = DeviceEvent.builder().unitId(UUID.randomUUID().toString()).versionId(UUID.randomUUID().toString()).build();
final DeviceConfiguration configuration = DeviceConfiguration.builder().build();
final Device device = Device.builder().lastEvent(event).configuration(configuration).unitId(UUID.randomUUID().toString()).build();
doReturn(new PagedResources<>(Collections.singletonList(device), new PagedResources.PageMetadata(1, 0, 1)))
.when(deviceServiceClient).getDevicesBySegment(userId, segmentId, pageable);
// When
Page<Device> result = segmentManager.getDevicesBySegment(userId, segmentId, pageable);
// Then
verify(deviceServiceClient).getDevicesBySegment(userId, segmentId, pageable);
assertThat(result).hasSize(1).contains(device);
}
@Test
public void getOrderedSegments_shouldCallClient_andReturnSegmentList() {
// Given
final String otherId = "other";
final String userId = UUID.randomUUID().toString();
final List<Segment> active = Arrays.asList(
Segment.builder().id(UUID.randomUUID().toString()).userId(userId).build(),
Segment.builder().id(UUID.randomUUID().toString()).userId(userId).build()
);
final List<Segment> inactive = Arrays.asList(
Segment.builder().id(UUID.randomUUID().toString()).userId(userId).build(),
Segment.builder().id(UUID.randomUUID().toString()).userId(userId).build()
);
final Segment other = Segment.builder()
.id(otherId)
.name("other")
.userId(userId)
.deviceCount(42)
.active(true)
.build();
final SegmentsOrder expected = SegmentsOrder.builder()
.active(active)
.inactive(inactive)
.other(other)
.build();
doReturn(active).when(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.ACTIVE);
doReturn(inactive).when(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.INACTIVE);
Stream.of(active, inactive).forEach(segments -> doReturn(segments).when(segmentManager).enhanceSegments(segments));
doReturn(other).when(segmentManager).getOtherSegment(userId);
// When
final SegmentsOrder result = segmentManager.getOrderedSegments(userId);
// Then
verify(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.ACTIVE);
verify(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.INACTIVE);
Stream.of(active, inactive).forEach(segments -> verify(segmentManager).enhanceSegments(segments));
verify(segmentManager).getOtherSegment(userId);
assertThat(result).isEqualTo(expected);
}
@Test
public void updateSegmentsOrder_shouldCallClient_andReturnIdxList() {
// Given
final String userId = UUID.randomUUID().toString();
final List<String> order = Arrays.asList(
UUID.randomUUID().toString(),
UUID.randomUUID().toString()
);
order.forEach(segmentId ->
doReturn(null).when(segmentManager).getSegmentAndCheckOwnership(userId, segmentId)
);
final List<String> expected = Arrays.asList(
UUID.randomUUID().toString(),
UUID.randomUUID().toString()
);
doReturn(expected).when(deviceServiceClient).updateSegmentsOrder(userId, order);
// When
final List<String> result = segmentManager.updateSegmentsOrder(userId, order);
// Then
order.forEach(segmentId ->
verify(segmentManager).getSegmentAndCheckOwnership(userId, segmentId)
);
verify(deviceServiceClient).updateSegmentsOrder(userId, order);
assertThat(result).containsExactlyElementsOf(expected);
}
@Test
public void getOtherSegment_shouldReturnSegmentWithDeviceCountAndFakeCharacteristics() {
// Given
final String segmentId = "other";
final String userId = UUID.randomUUID().toString();
final long count = new SecureRandom().nextLong();
final Segment expected = Segment.builder()
.id("other")
.active(true)
.deviceCount(count)
.name("Other")
.userId(userId)
.build();
doReturn(count).when(segmentManager).getDeviceCount(userId, segmentId);
// When
final Segment result = segmentManager.getOtherSegment(userId);
// Then
verify(segmentManager).getDeviceCount(userId, segmentId);
assertThat(result).isEqualTo(expected);
}
@Test
public void enhanceSegment_shouldCallEnhanceWithOneSegment_andReturnResult() {
// Given
final Segment segment = Segment.builder().id(UUID.randomUUID().toString()).build();
final Segment enhanced = Segment.builder().id(UUID.randomUUID().toString()).build();
doReturn(Collections.singletonList(enhanced)).when(segmentManager).enhanceSegments(Collections.singletonList(segment));
// When
final Segment result = segmentManager.enhanceSegment(segment);
// Then
verify(segmentManager).enhanceSegments(Collections.singletonList(segment));
assertThat(result).isEqualTo(enhanced);
}
@Test
public void enhanceSegments_whenEmptySegmentList_shouldReturnEmptyList() {
// Given
final List<Segment> noSegments = Collections.emptyList();
// When
final List<Segment> result = segmentManager.enhanceSegments(noSegments);
// Then
verify(segmentManager).enhanceSegments(noSegments);
verifyNoMoreInteractions(segmentManager);
assertThat(result).isEmpty();
}
@Test
public void enhanceSegments_whenSegmentList_shouldCheckForStatusAndGetDeviceCount() {
// Given
final String userId = UUID.randomUUID().toString();
final Segment active = Segment.builder()
.id(UUID.randomUUID().toString())
.userId(userId)
.build();
final Segment inactive = Segment.builder()
.id(UUID.randomUUID().toString())
.userId(userId)
.build();
final List<Segment> segments = Arrays.asList(inactive, active);
final List<Segment> activeSegments = Collections.singletonList(active);
final List<Segment> expected = Arrays.asList(
inactive.toBuilder().active(false).deviceCount(24L).build(),
active.toBuilder().active(true).deviceCount(42L).build()
);
doReturn(activeSegments).when(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.ACTIVE);
doReturn(42L).when(segmentManager).getDeviceCount(userId, active.getId());
doReturn(24L).when(segmentManager).getDeviceCount(userId, inactive.getId());
// When
final List<Segment> result = segmentManager.enhanceSegments(segments);
// Then
verify(deviceServiceClient).getSegmentsByStatus(userId, SegmentStatus.ACTIVE);
verify(segmentManager).getDeviceCount(userId, active.getId());
verify(segmentManager).getDeviceCount(userId, inactive.getId());
assertThat(result).containsExactlyElementsOf(expected);
}
@Test
public void getSegmentAndCheckOwnership_whenUserIsNotOwner_shouldThrowException() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final Segment original = Segment.builder().userId(UUID.randomUUID().toString()).build();
doReturn(original).when(deviceServiceClient).getSegment(segmentId);
// Then When
assertThatExceptionOfType(InvalidOwnerException.class)
.isThrownBy(() -> segmentManager.getSegmentAndCheckOwnership(userId, segmentId));
verify(deviceServiceClient).getSegment(segmentId);
}
@Test
public void getSegmentAndCheckOwnership_whenUserIsOwner_shouldCallClientAndReturnSegment() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final Segment expected = Segment.builder().userId(userId).name("aSegment").build();
doReturn(expected).when(deviceServiceClient).getSegment(segmentId);
// When
Segment result = segmentManager.getSegmentAndCheckOwnership(userId, segmentId);
// Then
verify(deviceServiceClient).getSegment(segmentId);
assertThat(result).isEqualTo(expected);
}
@Test
public void getDeviceCount_shouldCallServiceClientAndReturnTotalNumberOfDevices() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = UUID.randomUUID().toString();
final PageRequest request = new PageRequest(0, 1);
final PagedResources<DeviceEvent> clientResult = new PagedResources<>(
Collections.emptyList(),
new PagedResources.PageMetadata(1, 0, 42L)
);
doReturn(clientResult).when(deviceServiceClient).getDevicesBySegment(userId, segmentId, request);
// When
final long result = segmentManager.getDeviceCount(userId, segmentId);
// Then
verify(deviceServiceClient).getDevicesBySegment(userId, segmentId, request);
assertThat(result).isEqualTo(42L);
}
@Test
public void getDeviceCountForOther_shouldCallServiceClientAndReturnTotalNumberOfDevices() {
// Given
final String userId = UUID.randomUUID().toString();
final String segmentId = "other";
final PageRequest request = new PageRequest(0, 1);
final PagedResources<DeviceEvent> clientResult = new PagedResources<>(
Collections.emptyList(),
new PagedResources.PageMetadata(1, 0, 42L)
);
doReturn(clientResult).when(deviceServiceClient).getDevicesBySegment(userId, segmentId, request);
// When
final long result = segmentManager.getDeviceCount(userId, segmentId);
// Then
verify(deviceServiceClient).getDevicesBySegment(userId, segmentId, request);
assertThat(result).isEqualTo(42L);
}
} | 45.400468 | 157 | 0.691375 |
213ee67dd83e1f5264e6b9410471b2ef744a6acc | 12,263 | package com.github.gizmo0320.PowerfulPerms.common;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.concurrent.locks.ReentrantLock;
import com.github.gizmo0320.PowerfulPermsAPI.CachedGroup;
import com.github.gizmo0320.PowerfulPermsAPI.Group;
import com.github.gizmo0320.PowerfulPermsAPI.Permission;
import com.github.gizmo0320.PowerfulPermsAPI.PermissionPlayer;
import com.github.gizmo0320.PowerfulPermsAPI.PowerfulPermsPlugin;
public class PermissionPlayerBase extends PermissionContainer implements PermissionPlayer {
protected LinkedHashMap<String, List<CachedGroup>> groups = new LinkedHashMap<>(); // Contains -all- groups for this player.
protected List<Group> currentGroups = new ArrayList<>();
protected String prefix = "";
protected String suffix = "";
protected static PowerfulPermsPlugin plugin;
protected boolean isDefault = false;
protected ReentrantLock asyncGroupLock = new ReentrantLock();
public PermissionPlayerBase(LinkedHashMap<String, List<CachedGroup>> groups, List<Permission> permissions, String prefix, String suffix, PowerfulPermsPlugin plugin, boolean isDefault) {
super(permissions);
this.groups = groups;
this.prefix = prefix;
this.suffix = suffix;
PermissionPlayerBase.plugin = plugin;
this.isDefault = isDefault;
}
public void update(PermissionPlayerBase base) {
this.groups = base.groups;
this.ownPermissions = base.ownPermissions;
this.prefix = base.prefix;
this.suffix = base.suffix;
this.isDefault = base.isDefault;
}
public void updateGroups(String server) {
if (server == null || server.equalsIgnoreCase("all"))
server = "";
this.currentGroups = getGroups(server);
}
public void setGroups(LinkedHashMap<String, List<CachedGroup>> groups) {
asyncGroupLock.lock();
try {
this.groups = groups;
} finally {
asyncGroupLock.unlock();
}
}
/**
* Returns all groups a player has, including primary groups, indexed by server name.
*/
@Override
public LinkedHashMap<String, List<CachedGroup>> getCachedGroups() {
LinkedHashMap<String, List<CachedGroup>> output = new LinkedHashMap<>();
asyncGroupLock.lock();
try {
for (Entry<String, List<CachedGroup>> entry : this.groups.entrySet()) {
output.put(entry.getKey(), new ArrayList<>(entry.getValue()));
}
} finally {
asyncGroupLock.unlock();
}
return output;
}
public static List<CachedGroup> getCachedGroups(String server, LinkedHashMap<String, List<CachedGroup>> groups) {
List<CachedGroup> tempGroups = new ArrayList<>();
// Get server specific groups and add them
List<CachedGroup> serverGroupsTemp = groups.get(server);
if (serverGroupsTemp != null)
tempGroups.addAll(serverGroupsTemp);
// Get groups that apply on all servers and add them
if (!server.isEmpty()) {
List<CachedGroup> all = groups.get("");
if (all != null)
tempGroups.addAll(all);
}
return tempGroups;
}
/**
* Returns a list of cached groups which apply to a specific server.
*/
@Override
public List<CachedGroup> getCachedGroups(String server) {
asyncGroupLock.lock();
try {
return getCachedGroups(server, this.groups);
} finally {
asyncGroupLock.unlock();
}
}
public static List<Group> getGroups(List<CachedGroup> groups, PowerfulPermsPlugin plugin) {
List<Group> output = new ArrayList<>();
Iterator<CachedGroup> it1 = groups.iterator();
while (it1.hasNext()) {
CachedGroup cachedGroup = it1.next();
if (!cachedGroup.isNegated()) {
Group group = plugin.getPermissionManager().getGroup(cachedGroup.getGroupId());
if (group != null) {
output.add(group);
it1.remove();
}
}
}
// Remaining groups are negated
for (CachedGroup cachedGroup : groups) {
Iterator<Group> it2 = output.iterator();
while (it2.hasNext()) {
Group temp = it2.next();
if (temp.getId() == cachedGroup.getGroupId()) {
it2.remove();
plugin.debug("Removed negated group " + temp.getId());
}
}
}
return output;
}
/**
* Returns a list of groups which apply to a specific server. Removes negated groups.
*/
@Override
public List<Group> getGroups(String server) {
return getGroups(getCachedGroups(server), plugin);
}
/**
* Returns a list of groups which apply to the current server.
*/
@Override
public List<Group> getGroups() {
return new ArrayList<>(this.currentGroups);
}
/**
* Returns the player's group on a specific ladder.
*/
@Override
public Group getGroup(String ladder) {
List<Group> input = getGroups();
TreeMap<Integer, Group> sortedGroups = new TreeMap<>();
// Sort groups by rank if same ladder
for (Group group : input) {
if (group.getLadder().equalsIgnoreCase(ladder)) {
sortedGroups.put(group.getRank(), group);
}
}
Iterator<Group> it = sortedGroups.descendingMap().values().iterator();
if (it.hasNext()) {
return it.next();
}
return null;
}
public static Group getPrimaryGroup(List<Group> input) {
TreeMap<Integer, List<Group>> sortedGroups = new TreeMap<>();
for (Group group : input) {
List<Group> temp = sortedGroups.get(group.getRank());
if (temp == null)
temp = new ArrayList<>();
temp.add(group);
sortedGroups.put(group.getRank(), temp);
}
for (List<Group> tempGroups : sortedGroups.descendingMap().values()) {
for (Group group : tempGroups) {
if (group != null)
return group;
}
}
return null;
}
/**
* Returns the group with highest rank value across all ladders of the player.
*/
@Override
public Group getPrimaryGroup() {
return getPrimaryGroup(getGroups());
}
public static String getPrefix(String ladder, List<Group> input) {
TreeMap<Integer, List<Group>> sortedGroups = new TreeMap<>();
// Insert groups by rank value
for (Group group : input) {
if (ladder == null || group.getLadder().equalsIgnoreCase(ladder)) {
List<Group> temp = sortedGroups.get(group.getRank());
if (temp == null)
temp = new ArrayList<>();
temp.add(group);
sortedGroups.put(group.getRank(), temp);
}
}
// Return prefix from group with highest rank, if not found, move on to next rank
for (List<Group> tempGroups : sortedGroups.descendingMap().values()) {
for (Group group : tempGroups) {
String prefix = group.getPrefix(PermissionManagerBase.serverName);
if (!prefix.isEmpty())
return prefix;
}
}
return null;
}
/**
* Returns the player's prefix on a specific ladder.
*/
@Override
public String getPrefix(String ladder) {
return getPrefix(ladder, getGroups());
}
public static String getSuffix(String ladder, List<Group> input) {
TreeMap<Integer, List<Group>> sortedGroups = new TreeMap<>();
// Insert groups by rank value
for (Group group : input) {
if (ladder == null || group.getLadder().equalsIgnoreCase(ladder)) {
List<Group> temp = sortedGroups.get(group.getRank());
if (temp == null)
temp = new ArrayList<>();
temp.add(group);
sortedGroups.put(group.getRank(), temp);
}
}
// Return suffix from group with highest rank, if not found, move on to next rank
for (List<Group> tempGroups : sortedGroups.descendingMap().values()) {
for (Group group : tempGroups) {
String suffix = group.getSuffix(PermissionManagerBase.serverName);
if (!suffix.isEmpty())
return suffix;
}
}
return null;
}
/**
* Returns the player's suffix on a specific ladder.
*/
@Override
public String getSuffix(String ladder) {
return getSuffix(ladder, getGroups());
}
public static String getPrefix(List<Group> input, String ownPrefix) {
if (!ownPrefix.isEmpty())
return ownPrefix;
return getPrefix(null, input);
}
/**
* Returns the player's prefix from the group with highest rank across all ladders.
*/
@Override
public String getPrefix() {
if (!prefix.isEmpty())
return prefix;
return getPrefix(null, getGroups());
}
public static String getSuffix(List<Group> input, String ownSuffix) {
if (!ownSuffix.isEmpty())
return ownSuffix;
return getSuffix(null, input);
}
/**
* Returns the player's suffix from the group with highest rank across all ladders.
*/
@Override
public String getSuffix() {
if (!suffix.isEmpty())
return suffix;
return getSuffix(null, getGroups());
}
/**
* Returns the player's own prefix.
*/
@Override
public String getOwnPrefix() {
return prefix;
}
/**
* Returns the player's own suffix.
*/
@Override
public String getOwnSuffix() {
return suffix;
}
public static List<Permission> getAllPermissions(List<Group> input, PermissionContainer out, PowerfulPermsPlugin plugin) {
ArrayList<Permission> unprocessedPerms = new ArrayList<>();
// Add permissions from groups in normal order.
plugin.debug("groups count " + input.size());
TreeMap<Integer, List<Group>> sortedGroups = new TreeMap<>();
// Insert groups by rank value
for (Group group : input) {
List<Group> temp = sortedGroups.get(group.getRank());
if (temp == null)
temp = new ArrayList<>();
temp.add(group);
sortedGroups.put(group.getRank(), temp);
}
// Add permissions from sorted groups
for (List<Group> tempGroups : sortedGroups.values()) {
for (Group group : tempGroups) {
unprocessedPerms.addAll(group.getPermissions());
}
}
// Add own permissions.
unprocessedPerms.addAll(out.ownPermissions);
return unprocessedPerms;
}
public static List<String> calculatePermissions(String playerServer, String playerWorld, List<Group> input, PermissionContainer out, PowerfulPermsPlugin plugin) {
return calculatePermissions(playerServer, playerWorld, input, out, getAllPermissions(input, out, plugin), plugin);
}
public static List<String> calculatePermissions(String playerServer, String playerWorld, List<Group> input, PermissionContainer out, List<Permission> unprocessedPerms,
PowerfulPermsPlugin plugin) {
List<String> output = new ArrayList<>();
for (Permission e : unprocessedPerms) {
if (PermissionContainer.permissionApplies(e, playerServer, playerWorld)) {
output.add(e.getPermissionString());
}
}
if (plugin.isDebug()) {
for (String perm : output) {
plugin.debug("base added perm " + perm);
}
}
return output;
}
@Override
public boolean isDefault() {
return isDefault;
}
}
| 32.614362 | 189 | 0.59333 |
6b6d466f5b99e29aaf40aab29e56d364b8e56907 | 1,423 | /*
* ModeShape (http://www.modeshape.org)
*
* 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.modeshape.test.integration;
import javax.annotation.Resource;
import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
/**
* A class which provides via CDI injection various test repositories.
*
* @author Horia Chiorean (hchiorea@redhat.com)
*/
public class CDIRepositoryProvider {
@Resource( mappedName = "/jcr/sample" )
@Produces
private Repository sampleRepository;
@RequestScoped
@Produces
public Session getCurrentSession() throws RepositoryException {
return sampleRepository.login();
}
public void logoutSession( @Disposes final Session session ) {
session.logout();
}
}
| 30.276596 | 75 | 0.741391 |
900776da4ded968eef260e50ac5358ac772c8366 | 2,174 | package com.zzx.gank.ui.activity;
import android.content.Context;
import android.content.Intent;
import android.support.design.widget.TabLayout;
import android.support.v4.view.ViewPager;
import android.view.View;
import android.widget.ProgressBar;
import com.zzx.gank.R;
import com.zzx.gank.mvp.model.entity.Reader;
import com.zzx.gank.mvp.model.entity.ReaderCategory;
import com.zzx.gank.mvp.presenter.ReaderPresenter;
import com.zzx.gank.mvp.view.IReaderView;
import com.zzx.gank.ui.adatper.ReaderCategoryAdapter;
import java.util.List;
import butterknife.BindView;
public class ReaderActivity extends BaseActivity<ReaderPresenter> implements IReaderView {
@BindView(R.id.tab_layout)
TabLayout mTabLaout;
@BindView(R.id.container)
ViewPager mViewPager;
@BindView(R.id.progressbar)
ProgressBar progressbar;
private ReaderCategoryAdapter mReaderCategoryAdapter;
public static void show(Context context) {
Intent intent = new Intent(context, ReaderActivity.class);
context.startActivity(intent);
}
@Override
protected int getlayoutId() {
return R.layout.activity_reader;
}
@Override
protected void initPresenter() {
mPresenter = new ReaderPresenter(this, this);
mPresenter.attachView();
mPresenter.getReaderCategorys();
}
@Override
public void initView() {
}
@Override
public void showProgress() {
progressbar.setVisibility(View.VISIBLE);
}
@Override
public void hideProgress() {
progressbar.setVisibility(View.GONE);
}
@Override
public void showErrorView() {
progressbar.setVisibility(View.GONE);
}
@Override
public void showNoMoreData() {
progressbar.setVisibility(View.GONE);
}
@Override
public void showReaderList(List<Reader> readers) {
}
@Override
public void showReaderCategory(List<ReaderCategory> categories) {
mReaderCategoryAdapter = new ReaderCategoryAdapter(getSupportFragmentManager(), categories);
mViewPager.setAdapter(mReaderCategoryAdapter);
mTabLaout.setupWithViewPager(mViewPager);
}
}
| 24.704545 | 100 | 0.717111 |
760fb2fed828729299e1b40dd2c10c39df6bc595 | 2,120 | /**
* Copyright 2019 Pramati Prism, 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.github.srujankujmar.deployer.core.model;
import org.apache.commons.lang3.StringUtils;
/**
* status information of a service after deploying it.
*/
public class ServiceStatus {
private Integer exitCode;
private String message;
private String name;
private String k8sError;
public Integer getExitCode() {
return exitCode;
}
public void setExitCode(Integer exitCode) {
this.exitCode = exitCode;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getK8sError() {
return k8sError;
}
public void setK8sError(String k8sError) {
this.k8sError = k8sError;
}
@Override
public String toString() {
if (StringUtils.isEmpty(name)) {
return "";
}
StringBuilder sb = new StringBuilder("[");
sb.append("name: ").append(name);
if (!StringUtils.isEmpty(message)) {
sb.append(',').append("message: ").append(message);
}
if (!StringUtils.isEmpty(k8sError)) {
sb.append(',').append("k8sError: ").append(k8sError);
}
if (exitCode != null) {
sb.append(',').append("exitCode: ").append(exitCode);
}
sb.append(']');
return sb.toString();
}
}
| 26.17284 | 75 | 0.624528 |
f1b529ffc4371036db0feac17c851bedc6299145 | 1,799 | /*******************************************************************************
* Copyright SemanticBits, Northwestern University and Akaza Research
*
* Distributed under the OSI-approved BSD 3-Clause License.
* See http://ncip.github.com/caaers/LICENSE.txt for details.
******************************************************************************/
package gov.nih.nci.cabig.caaers.web.admin;
import gov.nih.nci.cabig.caaers.web.WebTestCase;
/**
* @author Sameer Work
*/
public class ImporterFactoryTest extends WebTestCase {
private ImporterFactory factory;
protected void setUp() throws Exception {
super.setUp();
factory = new ImporterFactory();
}
public void testCreateImporterInstance(){
Importer importer = factory.createImporterInstance("study");
assertTrue("Expected importer instance of type StudyImporter", importer instanceof StudyImporter);
importer = factory.createImporterInstance("participant");
assertTrue("Expected importer instance of type SubjectImporter", importer instanceof SubjectImporter);
importer = factory.createImporterInstance("researchStaff");
assertTrue("Expected importer instance of type ResearchStaffImporter", importer instanceof ResearchStaffImporter);
importer = factory.createImporterInstance("investigator");
assertTrue("Expected importer instance of type InvestigatorImporter", importer instanceof InvestigatorImporter);
importer = factory.createImporterInstance("agent");
assertTrue("Expected importer instance of type AgentImporter", importer instanceof AgentImporter);
importer = factory.createImporterInstance("organization");
assertTrue("Expected importer instance of type OrganizationImporter", importer instanceof OrganizationImporter);
}
}
| 40.886364 | 117 | 0.702613 |
1a281c000fb89b0a8545cdadc600a6fb63d85f1b | 9,606 | package org.contentmine.graphics.svg.path;
import java.io.File;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.contentmine.eucl.euclid.Real2Array;
import org.contentmine.graphics.AbstractCMElement;
import org.contentmine.graphics.svg.SVGG;
import org.contentmine.graphics.svg.SVGHTMLFixtures;
import org.contentmine.graphics.svg.SVGPath;
import org.contentmine.graphics.svg.SVGSVG;
import org.junit.Assert;
import org.junit.Test;
/** tests Path/DString parser.
*
* @author pm286
*
*/
public class SVGPathDStringParserTest {
private static final Logger LOG = Logger.getLogger(SVGPathDStringParserTest.class);
static {
LOG.setLevel(Level.DEBUG);
}
File TARGET_PATH = new File("target/path/");
public final static String dString =
"M327.397 218.898 L328.024 215.899 L329.074 215.899 C329.433 215.899 329.693 215.936 329.854 216.008" +
" C330.012 216.08 330.168 216.232 330.322 216.461 C330.546 216.793 330.745 217.186 330.92 217.64" +
" L331.404 218.898 L332.413 218.898 L331.898 217.626 C331.725 217.202 331.497 216.793 331.215 216.397" +
" C331.089 216.222 330.903 216.044 330.657 215.863 C331.46 215.755 332.039 215.52 332.4 215.158" +
" C332.759 214.796 332.938 214.341 332.938 213.791 C332.938 213.397 332.856 213.072 332.692 212.814" +
" C332.527 212.557 332.301 212.381 332.013 212.287 C331.724 212.192 331.3 212.146 330.741 212.146" +
" L327.908 212.146 L326.494 218.898 L327.397 218.898 ZM328.654 212.888 L330.857 212.888" +
" C331.203 212.888 331.448 212.914 331.593 212.967 C331.737 213.018 331.855 213.117 331.942 213.264" +
" C332.032 213.41 332.075 213.58 332.075 213.776 C332.075 214.011 332.017 214.228 331.898 214.431" +
" C331.779 214.634 331.609 214.794 331.39 214.914 C331.171 215.034 330.893 215.111 330.552 215.145" +
" C330.376 215.16 330 215.168 329.424 215.168 L328.176 215.168 L328.654 212.888";
@Test
public void testParseDString() {
PathPrimitiveList primitives = new SVGPathParser().parseDString(dString);
Assert.assertEquals("primitives", 31, primitives.size());
}
@Test
public void testParseD1() {
PathPrimitiveList primitiveList = new SVGPathParser().parseDString(dString);
String sig = primitiveList.createSignature();
Assert.assertEquals("signature", "MLLCCCLLLCCCCCCCLLLZMLCCCCCCCLL", sig);
}
@Test
public void testParseDString1() {
PathPrimitiveList primitiveList = new SVGPathParser().parseDString(dString);
String sig = primitiveList.createSignature();
Assert.assertEquals("signature", "MLLCCCLLLCCCCCCCLLLZMLCCCCCCCLL", sig);
}
@Test
public void testNormalize() {
String d = "M368.744 213.091 L368.943 212.146 L368.113 212.146 L367.915 213.091 L368.744 213.091 ZM367.532 218.898 L368.556 214.008 L367.722 214.008 L366.7 218.898 L367.532 218.898";
SVGPath path = new SVGPath();
path.setDString(d);
PathPrimitiveList primitives = new SVGPathParser().parseDString(d);
Real2Array r2a = path.getCoords();
path.normalizeOrigin();
Assert.assertEquals("normalized path",
"M2.044 0.945 L2.242 0.0 L1.413 0.0 L1.215 0.945 L2.044 0.945 ZM0.831 6.752 L1.855 1.862 L1.021 1.862 L0.0 6.752 L0.831 6.752",
//"M2.043 0.945 L2.242 0.0 L1.413 0.0 L1.215 0.945 L2.043 0.945 ZM0.832 6.751 L1.855 1.861 L1.021 1.861 L0.0 6.751 L0.832 6.751",
path.getDString().trim());
}
@Test
public void testRelativeMove() {
String d = "m 35.205,173.992 2.749,0 m 0.02,2.814 0,-2.748 m 74.217,2.748 0,-2.748 m 24.74,2.748 0,-2.748 "
+ "m -74.219,2.748 0,-2.748 m 24.74,2.748 0,-2.748 m 74.219,2.748 0,-2.748 m 24.74,2.748 0,-2.748 "
+ "m 24.738,2.978 0,-2.748 m 24.74,2.748 0,-2.748";
SVGPath path = new SVGPath();
path.setDString(d);
Real2Array r2a = path.getCoords();
r2a.format(3);
Assert.assertEquals("coords", "((35.205,173.992)(37.954,173.992)" // single horizonatl tick
+ "(37.974,176.806)(37.974,174.058)(112.191,176.806)(112.191,174.058)(136.931,176.806)(136.931,174.058)"
+ "(62.712,176.806)(62.712,174.058)(87.452,176.806)(87.452,174.058)(161.671,176.806)(161.671,174.058)"
+ "(186.411,176.806)(186.411,174.058)(211.149,177.036)(211.149,174.288)(235.889,177.036)(235.889,174.288))", r2a.toString());
}
@Test
public void testRelativeCubic() {
String d = "M 100,100 "
+ "m -10.306,34.147 "
+ "c 0,-0.842 0.549,-1.516 1.236,-1.516 "
+ "0.687,0 1.236,0.674 1.236,1.516 "
+ "0,0.84 -0.549,1.514 -1.236,1.514 "
+ "-0.687,0 -1.236,-0.674 -1.236,-1.514 "
+ "z "
+ "m 0.472,-23.202 "
+ "c 0,-0.842 0.549,-1.515 1.236,-1.515 "
+ "0.687,0 1.237,0.673 1.237,1.515 "
+ "0,0.842 -0.55,1.515 -1.237,1.515 "
+ "-0.687,0 -1.236,-0.673 -1.236,-1.515 "
+ "z";
SVGPath path = new SVGPath();
path.setDString(d);
Real2Array r2a = path.getCoords();
r2a.format(3);
Assert.assertEquals("coords", "((100.0,100.0)"
+ "(89.694,134.147)(89.694,133.305)(91.617,132.631)"
+ "(92.166,134.987)(90.243,135.661)(89.694,134.147)"
+ "(90.166,110.945)(90.166,110.103)(92.089,109.43)"
+ "(92.639,111.787)(90.715,112.46)(90.166,110.945))", r2a.toString());
}
@Test
public void testRelativeCubic1() {
AbstractCMElement svgElement = SVGSVG.readAndCreateSVG(new File(SVGHTMLFixtures.G_S_PATHS_DIR, "relcubics.svg"));
SVGPath path = SVGPath.extractPaths(svgElement).get(0);
path.detach();
path.getAttribute("stroke").detach();
path.setStroke("red");
SVGG g = new SVGG();
g.appendChild(path);
String d = path.getDString();
Assert.assertEquals("d", "M 400,180 350,60 m -60,120 60,-120"
+" m 0,0 c 0,-8 5,-15 12,-15 6,0 12,6 12,15 0,8 -5,15 -12,15 -6,0 -12,-6 -12,-15 z"
+" m 0,0 c 0,-8 5,-15 12,-15 6,0 12,6 12,15 0,8 -5,15 -12,15 -6,0 -12,-6 -12,-15 z",
d);
PathPrimitiveList primitives = new SVGPathParser().parseDString(d);
SVGPath path1 = new SVGPath(primitives, null);
path1.setStroke("blue");
String d1 = path1.getDString();
Assert.assertEquals("d", "M400.0 180.0 L350.0 60.0 M290.0 180.0 L350.0 60.0 M350.0 60.0 C350.0 52.0 355.0 45.0 362.0 45.0 C368.0 45.0 374.0 51.0 374.0 60.0 C374.0 68.0 369.0 75.0 362.0 75.0 C356.0 75.0 350.0 69.0 350.0 60.0 ZM350.0 60.0 C350.0 52.0 355.0 45.0 362.0 45.0 C368.0 45.0 374.0 51.0 374.0 60.0 C374.0 68.0 369.0 75.0 362.0 75.0 C356.0 75.0 350.0 69.0 350.0 60.0 Z",
d1);
g.appendChild(path1);
SVGSVG.wrapAndWriteAsSVG(g, new File(TARGET_PATH, "relcubic1.svg"));
}
@Test
public void testRelativeCubic1a() {
AbstractCMElement svgElement = SVGSVG.readAndCreateSVG(new File(SVGHTMLFixtures.G_S_PATHS_DIR, "relcubics.svg"));
SVGPath path = SVGPath.extractPaths(svgElement).get(0);
path.detach();
path.getAttribute("stroke").detach();
path.setStroke("red");
path.setStrokeWidth(1.5);
SVGG g = new SVGG();
g.appendChild(path);
String d = path.getDString();
Assert.assertEquals("d", "M 400,180 350,60 m -60,120 60,-120"
+ " m 0,0 c 0,-8 5,-15 12,-15 6,0 12,6 12,15 0,8 -5,15 -12,15 -6,0 -12,-6 -12,-15 z"
+ " m 0,0 c 0,-8 5,-15 12,-15 6,0 12,6 12,15 0,8 -5,15 -12,15 -6,0 -12,-6 -12,-15 z",
d);
PathPrimitiveList primitives = new SVGPathParser().parseDString(d);
SVGPath path1 = new SVGPath(primitives, null);
path1.setStroke("blue");
path.setStrokeWidth(1.0);
String d1 = path1.getDString();
g.appendChild(path1);
SVGSVG.wrapAndWriteAsSVG(g, new File(TARGET_PATH, "relcubic1a.svg"));
}
@Test
public void testRelativeCubic2() {
String d = ""
+ "M 100 100 "
+ " m 20,0 0,30 -20,0 0,-30 z"
+ " c -7,-10 -13,-10 -20,0 "
+ " c -7,10 -7,20 0,30 "
+ " c 7,10 13,10 20,0 "
+ " c 7,-10 7,-20 0,-30 "
+ "z"
;
PathPrimitiveList primitives = new SVGPathParser().parseDString(d);
SVGPath path = new SVGPath(primitives, null);
path.setStroke("red");
SVGSVG.wrapAndWriteAsSVG(path, new File(TARGET_PATH, "relcubic2a.svg"));
SVGPath path1 = new SVGPath(primitives);
path1.setStroke("blue");
String d1 = path1.getDString();
Assert.assertEquals("d",
"M100.0 100.0 M120.0 100.0 L120.0 130.0 L100.0 130.0 L100.0 100.0 ZC113.0 90.0 107.0 90.0 100.0 100.0 C93.0 110.0 93.0 120.0 100.0 130.0 C107.0 140.0 113.0 140.0 120.0 130.0 C127.0 120.0 127.0 110.0 120.0 100.0 Z",
d1);
SVGSVG.wrapAndWriteAsSVG(path, new File(TARGET_PATH, "relcubic2b.svg"));
}
@Test
public void testRelativeCubic3() {
SVGG g = new SVGG();
String d = ""
+ "M 100 100 "
+ " m 20,0 0,30 -20,0 0,-30 z"
+ " c -7,-10 -13,-10 -20,0 "
+ " c -7,10 -7,20 0,30 "
+ " c 7,10 13,10 20,0 "
+ " c 7,-10 7,-20 0,-30 "
+ "z"
+ "M 200 200 "
+ " m 20,0 0,30 -20,0 0,-30 z"
+ " c -7,-10 -13,-10 -20,0 "
+ " c -7,10 -7,20 0,30 "
+ " c 7,10 13,10 20,0 "
+ " c 7,-10 7,-20 0,-30 "
+ "z"
+ "M 300 300 "
+ " m 20,0 0,30 -20,0 0,-30 z"
+ " c -7,-10 -13,-10 -20,0 "
+ " c -7,10 -7,20 0,30 "
+ " c 7,10 13,10 20,0 "
+ " c 7,-10 7,-20 0,-30 "
+ "z"
;
PathPrimitiveList primitives = new SVGPathParser().parseDString(d);
SVGPath path = new SVGPath(primitives, null);
path.setStroke("red");
path.setStrokeWidth(1.0);
g.appendChild(path);
SVGPath path1 = new SVGPath(primitives);
path1.setStroke("blue");
g.appendChild(path1);
SVGSVG.wrapAndWriteAsSVG(g, new File(TARGET_PATH, "relcubic3.svg"));
}
}
| 41.405172 | 379 | 0.627004 |
2ec9c84c1acf231ab630f98f74dc1a756c32fbd3 | 1,903 | /*
package unit.com.bitdubai.fermat_ccp_plugin.layer.actor.intra_user.developer.bitdubai.version_1.structure.IntraWalletUserActor;
import com.bitdubai.fermat_ccp_api.layer.actor.intra_wallet_user.enums.ContactState;
import com.bitdubai.fermat_api.layer.osa_android.file_system.PluginFileSystem;
import com.bitdubai.fermat_ccp_plugin.layer.actor.intra_user.developer.bitdubai.version_1.structure.IntraWalletUserActor;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import static org.fest.assertions.api.Assertions.assertThat;
*/
/**
* Created by natalia on 24/08/15.
*//*
public class Getters_Identity_Test {
IntraWalletUserActor intraUserActor;
String name;
String publicKey;
byte[] profileImage;
long registrationDate;
ContactState contactState;
@Mock
private PluginFileSystem mockPluginFileSystem;
@Before
public void setUpVariable1(){
name = "alias";
publicKey= "publicKey";
profileImage = new byte[10];
registrationDate = 12653;
contactState = ContactState.CONNECTED;
intraUserActor = new IntraWalletUserActor(name,publicKey, profileImage,registrationDate,contactState );
}
@Test
public void GetNameAreEquals(){
assertThat(intraUserActor.getName()).isEqualTo(name);
}
@Test
public void GetPublicKeyAreEquals(){
assertThat(intraUserActor.getPublicKey()).isEqualTo(publicKey);
}
@Test
public void GetProfileImage_AreEquals() {
assertThat(intraUserActor.getProfileImage()).isEqualTo(profileImage);
}
@Test
public void GetRegistrationDateAreEquals(){
assertThat(intraUserActor.getContactRegistrationDate()).isEqualTo(registrationDate);
}
@Test
public void GetContactStateAreEquals() {
assertThat(intraUserActor.getContactState()).isEqualTo(contactState);
}
}
*/
| 25.716216 | 127 | 0.735155 |
32a0c6392c38acf1499a7903f27c37a62f9d4713 | 302 | package gr.iti.mklab.framework.client.search.solr.beans;
import org.apache.solr.client.solrj.beans.Field;
public class Bean {
@Field(value = "id")
protected String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
| 15.894737 | 56 | 0.619205 |
aecd6b59ef2b29c1fc0b8f9915bb3286b6103163 | 3,804 | package org.fluentcodes.projects.elasticobjects.calls.db;
import org.fluentcodes.projects.elasticobjects.calls.HostBean;
import org.fluentcodes.projects.elasticobjects.calls.HostConfig;
import org.fluentcodes.projects.elasticobjects.exceptions.EoException;
import org.fluentcodes.projects.elasticobjects.exceptions.EoInternalException;
import org.fluentcodes.projects.elasticobjects.models.ConfigBean;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* Created by Werner on 09.10.2016.
*/
public class DbConfig extends HostConfig implements DbConfigInterface {
public static final String H2_BASIC = "h2:mem:basic";
private Connection connection;
public DbConfig(final ConfigBean configBean) {
this((HostBean)configBean);
}
public DbConfig(final HostBean bean) {
super(bean);
}
public static final void closeStatement(Statement statement) {
if (statement == null) {
return;
}
try {
statement.close();
} catch (Exception e) {
statement = null;
new EoInternalException("Exception closing statement : " + e.getMessage());
}
}
public static final void closeResultSet(ResultSet resultSet) {
if (resultSet == null) {
return;
}
try {
resultSet.close();
} catch (Exception e) {
resultSet = null;
throw new EoInternalException("Exception closing resultSet: " + e.getMessage());
}
}
public static final void closeAll(Statement statement, ResultSet resultSet) {
closeResultSet(resultSet);
closeStatement(statement);
}
public Connection getConnection() {
if (this.connection != null) {
try {
if (!connection.isClosed()) {
return this.connection;
}
} catch (SQLException e) {
throw new EoInternalException(e);
}
}
if (!hasDbType()) {
throw new EoException("No dbType defined, so no driver could be set '" + getNaturalId() + "'.");
}
if (getDbType().getDriver() == null) {
throw new EoException("No driver is addList for '" + getNaturalId() + "'.");
}
try {
Class.forName(getDbType().getDriver());
String url = getUrlPath();
connection = DriverManager.getConnection(url, getUser(), getPassword());
return connection;
}
catch (ClassNotFoundException|SQLException e) {
throw new EoException(e);
}
}
public void closeConnection() {
if (connection == null) {
throw new EoException("No connection initialized for '" + getNaturalId() + "'.");
}
try {
connection.close();
} catch (SQLException e) {
throw new EoException(e);
}
connection = null;
}
@Override
public String getUrlPath() {
if (hasUrlCache()) {
return getUrlCache();
}
if (hasUrlCache()) {
super.getUrl();
}
StringBuffer urlPath = new StringBuffer();
if (hasProtocol()) {
urlPath.append(getProtocol());
}
if (hasHostName()) {
urlPath.append(":");
urlPath.append(getHostName());
}
if (hasSchema()) {
urlPath.append(":");
urlPath.append(getSchema());
}
if (hasExtension()) {
urlPath.append( ";");
urlPath.append(getExtension());
}
setUrlCache(urlPath.toString());
return getUrlCache();
}
}
| 30.677419 | 108 | 0.575184 |
09fe17c1fc058bd4a7ff47db92414ad976c2a7d2 | 1,581 | /*
* Copyright OpenSearch Contributors
* SPDX-License-Identifier: Apache-2.0
*/
package com.amazon.dataprepper.pipeline.server;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyStore;
public class SslUtil {
public static SSLContext createSslContext(final String keyStoreFilePath,
final String keyStorePassword,
final String privateKeyPassword) {
final SSLContext sslContext;
try {
final KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(Files.newInputStream(Paths.get(keyStoreFilePath)), keyStorePassword.toCharArray());
final KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(keyStore, privateKeyPassword.toCharArray());
final TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustManagerFactory.init(keyStore);
sslContext = SSLContext.getInstance("TLS");
sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
} catch (Exception e) {
throw new IllegalStateException("Problem loading keystore to create SSLContext", e);
}
return sslContext;
}
}
| 38.560976 | 135 | 0.696395 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.