repo_name stringlengths 7 104 | file_path stringlengths 13 198 | context stringlengths 67 7.15k | import_statement stringlengths 16 4.43k | code stringlengths 40 6.98k | prompt stringlengths 227 8.27k | next_line stringlengths 8 795 |
|---|---|---|---|---|---|---|
wdiestel/arbaro | src/net/sourceforge/arbaro/export/RIBSceneExporter.java | // Path: src/net/sourceforge/arbaro/params/FloatFormat.java
// public class FloatFormat {
//
// public static NumberFormat getInstance() {
// NumberFormat form = NumberFormat.getNumberInstance(Locale.US);
// form.setMaximumFractionDigits(5);
// form.setMinimumFractionDigits(0);
// return form;
// }
// }
//
// Path: src/net/sourceforge/arbaro/tree/Tree.java
// public interface Tree {
//
// /**
// * used with the TreeTraversal interface
// *
// * @param traversal
// * @return when false stop travers the tree
// */
// abstract boolean traverseTree(TreeTraversal traversal);
//
// /**
// *
// * @return the number of all stems of all levels of the tree
// */
// public abstract long getStemCount();
//
// /**
// *
// * @return the number of leaves of the tree
// */
// public abstract long getLeafCount();
//
// /**
// *
// * @return a vector with the highest coordinates of the tree.
// * (Considering all stems of all levels)
// */
// public abstract Vector getMaxPoint();
//
// /**
// *
// * @return a vector with the lowest coordinates of the tree.
// * (Considering all stems of all levels)
// */
// public abstract Vector getMinPoint();
//
// /**
// *
// * @return the seed of the tree. It is used for randomnization.
// */
// public int getSeed();
//
// /**
// *
// * @return the height of the tree (highest z-coordinate)
// */
// public double getHeight();
//
// /**
// *
// * @return the widht of the tree (highest value of sqrt(x*x+y*y))
// */
// public double getWidth();
//
// /**
// * Writes the trees parameters to a stream
// * @param w
// */
// public void paramsToXML(PrintWriter w);
//
// /**
// *
// * @return the tree species name
// */
// public String getSpecies();
//
// /**
// *
// * @return the tree scale
// */
// public double getScale();
//
// /**
// *
// * @return the tree stem levels
// */
// public int getLevels();
//
// /**
// *
// * @return the leaf shape name
// */
// public String getLeafShape();
//
// /**
// *
// * @return the leaf width
// */
// public double getLeafWidth();
//
// /**
// *
// * @return the leaf length
// */
// public double getLeafLength();
//
// /**
// *
// * @return the virtual leaf stem length, i.e. the distance of
// * the leaf from the stem center line
// */
// public double getLeafStemLength();
//
// /**
// * Use this for verbose output when generating a mesh or
// * exporting a tree
// *
// * @param level
// * @return an information string with the number of section
// * points for this stem level and if smoothing should be used
// */
// public String getVertexInfo(int level);
//
// }
| import java.io.File;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import net.sourceforge.arbaro.params.FloatFormat;
import net.sourceforge.arbaro.tree.Tree;
| //#**************************************************************************
//#
//# Copyright (C) 2008 Moritz Moeller
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//#
//# Send comments and bug fixes to arbaro@virtualritz.com or
//# diestel@steloj.de
//#
//#**************************************************************************/
package net.sourceforge.arbaro.export;
/**
* Creates a RenderMan scene file with the rendered tree
* included.
*
*/
class RIBSceneExporter extends AbstractExporter {
Tree tree;
int renderWidth;
int renderHeight;
String namePrefix;
String archiveFile;
String image;
StringIndenter indent=new StringIndenter(" ");
| // Path: src/net/sourceforge/arbaro/params/FloatFormat.java
// public class FloatFormat {
//
// public static NumberFormat getInstance() {
// NumberFormat form = NumberFormat.getNumberInstance(Locale.US);
// form.setMaximumFractionDigits(5);
// form.setMinimumFractionDigits(0);
// return form;
// }
// }
//
// Path: src/net/sourceforge/arbaro/tree/Tree.java
// public interface Tree {
//
// /**
// * used with the TreeTraversal interface
// *
// * @param traversal
// * @return when false stop travers the tree
// */
// abstract boolean traverseTree(TreeTraversal traversal);
//
// /**
// *
// * @return the number of all stems of all levels of the tree
// */
// public abstract long getStemCount();
//
// /**
// *
// * @return the number of leaves of the tree
// */
// public abstract long getLeafCount();
//
// /**
// *
// * @return a vector with the highest coordinates of the tree.
// * (Considering all stems of all levels)
// */
// public abstract Vector getMaxPoint();
//
// /**
// *
// * @return a vector with the lowest coordinates of the tree.
// * (Considering all stems of all levels)
// */
// public abstract Vector getMinPoint();
//
// /**
// *
// * @return the seed of the tree. It is used for randomnization.
// */
// public int getSeed();
//
// /**
// *
// * @return the height of the tree (highest z-coordinate)
// */
// public double getHeight();
//
// /**
// *
// * @return the widht of the tree (highest value of sqrt(x*x+y*y))
// */
// public double getWidth();
//
// /**
// * Writes the trees parameters to a stream
// * @param w
// */
// public void paramsToXML(PrintWriter w);
//
// /**
// *
// * @return the tree species name
// */
// public String getSpecies();
//
// /**
// *
// * @return the tree scale
// */
// public double getScale();
//
// /**
// *
// * @return the tree stem levels
// */
// public int getLevels();
//
// /**
// *
// * @return the leaf shape name
// */
// public String getLeafShape();
//
// /**
// *
// * @return the leaf width
// */
// public double getLeafWidth();
//
// /**
// *
// * @return the leaf length
// */
// public double getLeafLength();
//
// /**
// *
// * @return the virtual leaf stem length, i.e. the distance of
// * the leaf from the stem center line
// */
// public double getLeafStemLength();
//
// /**
// * Use this for verbose output when generating a mesh or
// * exporting a tree
// *
// * @param level
// * @return an information string with the number of section
// * points for this stem level and if smoothing should be used
// */
// public String getVertexInfo(int level);
//
// }
// Path: src/net/sourceforge/arbaro/export/RIBSceneExporter.java
import java.io.File;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import net.sourceforge.arbaro.params.FloatFormat;
import net.sourceforge.arbaro.tree.Tree;
//#**************************************************************************
//#
//# Copyright (C) 2008 Moritz Moeller
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//#
//# Send comments and bug fixes to arbaro@virtualritz.com or
//# diestel@steloj.de
//#
//#**************************************************************************/
package net.sourceforge.arbaro.export;
/**
* Creates a RenderMan scene file with the rendered tree
* included.
*
*/
class RIBSceneExporter extends AbstractExporter {
Tree tree;
int renderWidth;
int renderHeight;
String namePrefix;
String archiveFile;
String image;
StringIndenter indent=new StringIndenter(" ");
| NumberFormat frm = FloatFormat.getInstance();
|
offbynull/actors | redis-storage/src/main/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueue.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/SortedSetItem.java
// public final class SortedSetItem {
//
// private final double score;
// private final Object item;
//
// /**
// * Constructs a {@link SortedSetItem} object.
// * @param score score
// * @param item item
// */
// public SortedSetItem(double score, Object item) {
// this.score = score;
// this.item = item;
// }
//
// /**
// * Get score.
// * @return score
// */
// public double getScore() {
// return score;
// }
//
// /**
// * Get item.
// * @param <T> expected type
// * @return item
// * @throws ClassCastException if expected type is not the type stored
// */
// public <T> T getItem() {
// return (T) item;
// }
//
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Transaction.java
// public final class Transaction {
//
// private final TransactionBlock block;
// private final boolean retry;
//
// /**
// * Constructs a {@link Transaction} object.
// * @param retry if {@code true}, transaction will be retried until it passes
// * @param block block that defines queued transaction operations
// * @throws NullPointerException if any argument is {@code null}
// */
// public Transaction(boolean retry, TransactionBlock block) {
// Validate.notNull(block);
// this.retry = retry;
// this.block = block;
// }
//
// /**
// * Get retry flag.
// * @return if {@code true}, transaction will be retried until it passes
// */
// public boolean isRetry() {
// return retry;
// }
//
// /**
// * Get transaction block.
// * @return block that defines queued transaction operations
// */
// public TransactionBlock getBlock() {
// return block;
// }
//
// }
| import com.offbynull.actors.address.Address;
import org.apache.commons.lang3.Validate;
import java.util.Collection;
import com.offbynull.actors.redisclient.Connection;
import com.offbynull.actors.redisclient.ConnectionException;
import com.offbynull.actors.redisclient.SortedSetItem;
import com.offbynull.actors.redisclient.Transaction;
import com.offbynull.actors.redisclient.TransactionResult;
import com.offbynull.actors.redisclient.Watch; | /*
* Copyright (c) 2017, Kasra Faghihi, All rights reserved.
*
* 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 3.0 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.
*/
package com.offbynull.actors.gateways.actor.stores.redis;
/**
* Timestamp queue -- a queue of (timestamp, address) pairs that's sorted in ascending order by timestamp.
* <p>
* Unless there's a critical error, implementations are required to retry indefinity the operation until it succeeds. The following are not
* considered to be critical errors...
* <ul>
* <li>Connection problems.</li>
* <li>Redis MULTI/EXEC transactions that fail because a WATCH failed are not critical errors.</li>
* </ul>
* @author Kasra Faghihi
*/
final class TimestampQueue {
private static final String KEY_PREFIX = "timestampqueue:";
private final Connection connection;
private final String queueKey;
TimestampQueue(Connection connection, String name, int num) {
Validate.notNull(name);
Validate.notNull(connection);
this.queueKey = KEY_PREFIX + name + ':' + num;
this.connection = connection;
}
// remove next item (only if the timestamp for the next item <= currentTimestamp)
public Address remove(long minTimestamp) throws ConnectionException {
Validate.isTrue(minTimestamp >= 0L);
TransactionResult res = connection.transaction( | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/SortedSetItem.java
// public final class SortedSetItem {
//
// private final double score;
// private final Object item;
//
// /**
// * Constructs a {@link SortedSetItem} object.
// * @param score score
// * @param item item
// */
// public SortedSetItem(double score, Object item) {
// this.score = score;
// this.item = item;
// }
//
// /**
// * Get score.
// * @return score
// */
// public double getScore() {
// return score;
// }
//
// /**
// * Get item.
// * @param <T> expected type
// * @return item
// * @throws ClassCastException if expected type is not the type stored
// */
// public <T> T getItem() {
// return (T) item;
// }
//
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Transaction.java
// public final class Transaction {
//
// private final TransactionBlock block;
// private final boolean retry;
//
// /**
// * Constructs a {@link Transaction} object.
// * @param retry if {@code true}, transaction will be retried until it passes
// * @param block block that defines queued transaction operations
// * @throws NullPointerException if any argument is {@code null}
// */
// public Transaction(boolean retry, TransactionBlock block) {
// Validate.notNull(block);
// this.retry = retry;
// this.block = block;
// }
//
// /**
// * Get retry flag.
// * @return if {@code true}, transaction will be retried until it passes
// */
// public boolean isRetry() {
// return retry;
// }
//
// /**
// * Get transaction block.
// * @return block that defines queued transaction operations
// */
// public TransactionBlock getBlock() {
// return block;
// }
//
// }
// Path: redis-storage/src/main/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueue.java
import com.offbynull.actors.address.Address;
import org.apache.commons.lang3.Validate;
import java.util.Collection;
import com.offbynull.actors.redisclient.Connection;
import com.offbynull.actors.redisclient.ConnectionException;
import com.offbynull.actors.redisclient.SortedSetItem;
import com.offbynull.actors.redisclient.Transaction;
import com.offbynull.actors.redisclient.TransactionResult;
import com.offbynull.actors.redisclient.Watch;
/*
* Copyright (c) 2017, Kasra Faghihi, All rights reserved.
*
* 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 3.0 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.
*/
package com.offbynull.actors.gateways.actor.stores.redis;
/**
* Timestamp queue -- a queue of (timestamp, address) pairs that's sorted in ascending order by timestamp.
* <p>
* Unless there's a critical error, implementations are required to retry indefinity the operation until it succeeds. The following are not
* considered to be critical errors...
* <ul>
* <li>Connection problems.</li>
* <li>Redis MULTI/EXEC transactions that fail because a WATCH failed are not critical errors.</li>
* </ul>
* @author Kasra Faghihi
*/
final class TimestampQueue {
private static final String KEY_PREFIX = "timestampqueue:";
private final Connection connection;
private final String queueKey;
TimestampQueue(Connection connection, String name, int num) {
Validate.notNull(name);
Validate.notNull(connection);
this.queueKey = KEY_PREFIX + name + ':' + num;
this.connection = connection;
}
// remove next item (only if the timestamp for the next item <= currentTimestamp)
public Address remove(long minTimestamp) throws ConnectionException {
Validate.isTrue(minTimestamp >= 0L);
TransactionResult res = connection.transaction( | new Transaction(true, queue -> { |
offbynull/actors | redis-storage/src/main/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueue.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/SortedSetItem.java
// public final class SortedSetItem {
//
// private final double score;
// private final Object item;
//
// /**
// * Constructs a {@link SortedSetItem} object.
// * @param score score
// * @param item item
// */
// public SortedSetItem(double score, Object item) {
// this.score = score;
// this.item = item;
// }
//
// /**
// * Get score.
// * @return score
// */
// public double getScore() {
// return score;
// }
//
// /**
// * Get item.
// * @param <T> expected type
// * @return item
// * @throws ClassCastException if expected type is not the type stored
// */
// public <T> T getItem() {
// return (T) item;
// }
//
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Transaction.java
// public final class Transaction {
//
// private final TransactionBlock block;
// private final boolean retry;
//
// /**
// * Constructs a {@link Transaction} object.
// * @param retry if {@code true}, transaction will be retried until it passes
// * @param block block that defines queued transaction operations
// * @throws NullPointerException if any argument is {@code null}
// */
// public Transaction(boolean retry, TransactionBlock block) {
// Validate.notNull(block);
// this.retry = retry;
// this.block = block;
// }
//
// /**
// * Get retry flag.
// * @return if {@code true}, transaction will be retried until it passes
// */
// public boolean isRetry() {
// return retry;
// }
//
// /**
// * Get transaction block.
// * @return block that defines queued transaction operations
// */
// public TransactionBlock getBlock() {
// return block;
// }
//
// }
| import com.offbynull.actors.address.Address;
import org.apache.commons.lang3.Validate;
import java.util.Collection;
import com.offbynull.actors.redisclient.Connection;
import com.offbynull.actors.redisclient.ConnectionException;
import com.offbynull.actors.redisclient.SortedSetItem;
import com.offbynull.actors.redisclient.Transaction;
import com.offbynull.actors.redisclient.TransactionResult;
import com.offbynull.actors.redisclient.Watch; | //
// long precisionLossTime = 1L << 53L;
// Instant i = Instant.ofEpochMilli(precisionLossTime);
// ZonedDateTime zdt = ZonedDateTime.ofInstant(i, ZoneId.systemDefault());
// System.out.println(zdt);
//
// +287396-10-12T01:59:00.992-07:00[America/Los_Angeles]
//
//
// Tests on redis-cli confirm this (tested on 64-bit Redis). 2^53 = 9007199254740992... when we use that as the score for a
// member in a sorted set and get it back out, we get back the exact same score...
// 127.0.0.1:6379> zadd ztest 9007199254740992 "a"
// (integer) 1
// 127.0.0.1:6379> zrange ztest 0 1000 WITHSCORES
// 1) "a"
// 2) "9007199254740992"
//
// When we use a larger number, we get back a score that has precision loss in the integer portion....
// 127.0.0.1:6379> zadd ztest 99999007199254740992 "b"
// (integer) 1
// 127.0.0.1:6379> zrange ztest 0 1000 WITHSCORES
// 1) "b"
// 2) "9.9999007199254741e+19"
//
//
// We can safely ignore the precision loss from the conversion to a double -- the year 287396 is too far off to care about.
}
// peek the timestamp of the next item in the inspection queue
private long peekTimestamp() throws ConnectionException { | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/SortedSetItem.java
// public final class SortedSetItem {
//
// private final double score;
// private final Object item;
//
// /**
// * Constructs a {@link SortedSetItem} object.
// * @param score score
// * @param item item
// */
// public SortedSetItem(double score, Object item) {
// this.score = score;
// this.item = item;
// }
//
// /**
// * Get score.
// * @return score
// */
// public double getScore() {
// return score;
// }
//
// /**
// * Get item.
// * @param <T> expected type
// * @return item
// * @throws ClassCastException if expected type is not the type stored
// */
// public <T> T getItem() {
// return (T) item;
// }
//
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Transaction.java
// public final class Transaction {
//
// private final TransactionBlock block;
// private final boolean retry;
//
// /**
// * Constructs a {@link Transaction} object.
// * @param retry if {@code true}, transaction will be retried until it passes
// * @param block block that defines queued transaction operations
// * @throws NullPointerException if any argument is {@code null}
// */
// public Transaction(boolean retry, TransactionBlock block) {
// Validate.notNull(block);
// this.retry = retry;
// this.block = block;
// }
//
// /**
// * Get retry flag.
// * @return if {@code true}, transaction will be retried until it passes
// */
// public boolean isRetry() {
// return retry;
// }
//
// /**
// * Get transaction block.
// * @return block that defines queued transaction operations
// */
// public TransactionBlock getBlock() {
// return block;
// }
//
// }
// Path: redis-storage/src/main/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueue.java
import com.offbynull.actors.address.Address;
import org.apache.commons.lang3.Validate;
import java.util.Collection;
import com.offbynull.actors.redisclient.Connection;
import com.offbynull.actors.redisclient.ConnectionException;
import com.offbynull.actors.redisclient.SortedSetItem;
import com.offbynull.actors.redisclient.Transaction;
import com.offbynull.actors.redisclient.TransactionResult;
import com.offbynull.actors.redisclient.Watch;
//
// long precisionLossTime = 1L << 53L;
// Instant i = Instant.ofEpochMilli(precisionLossTime);
// ZonedDateTime zdt = ZonedDateTime.ofInstant(i, ZoneId.systemDefault());
// System.out.println(zdt);
//
// +287396-10-12T01:59:00.992-07:00[America/Los_Angeles]
//
//
// Tests on redis-cli confirm this (tested on 64-bit Redis). 2^53 = 9007199254740992... when we use that as the score for a
// member in a sorted set and get it back out, we get back the exact same score...
// 127.0.0.1:6379> zadd ztest 9007199254740992 "a"
// (integer) 1
// 127.0.0.1:6379> zrange ztest 0 1000 WITHSCORES
// 1) "a"
// 2) "9007199254740992"
//
// When we use a larger number, we get back a score that has precision loss in the integer portion....
// 127.0.0.1:6379> zadd ztest 99999007199254740992 "b"
// (integer) 1
// 127.0.0.1:6379> zrange ztest 0 1000 WITHSCORES
// 1) "b"
// 2) "9.9999007199254741e+19"
//
//
// We can safely ignore the precision loss from the conversion to a double -- the year 287396 is too far off to care about.
}
// peek the timestamp of the next item in the inspection queue
private long peekTimestamp() throws ConnectionException { | Collection<SortedSetItem> result = connection.zrangeWithScores(queueKey, 0L, 0L, ConversionUtils::byteArrayToString); |
offbynull/actors | redis-storage/src/test/java/com/offbynull/actors/gateways/servlet/stores/redis/RedisStoreTest.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
| import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import com.offbynull.actors.shuttle.Message;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException; |
package com.offbynull.actors.gateways.servlet.stores.redis;
public class RedisStoreTest {
private RedisStore fixture;
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Before
public void before() {
// try (Jedis jedis = new Jedis("192.168.206.110", 6379)) {
// jedis.flushDB();
// }
// Connector connector = new JedisPoolConnector("192.168.206.110", 6379, 5);
| // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
// Path: redis-storage/src/test/java/com/offbynull/actors/gateways/servlet/stores/redis/RedisStoreTest.java
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import com.offbynull.actors.shuttle.Message;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
package com.offbynull.actors.gateways.servlet.stores.redis;
public class RedisStoreTest {
private RedisStore fixture;
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Before
public void before() {
// try (Jedis jedis = new Jedis("192.168.206.110", 6379)) {
// jedis.flushDB();
// }
// Connector connector = new JedisPoolConnector("192.168.206.110", 6379, 5);
| Connector connector = new TestConnector(); |
offbynull/actors | redis-storage/src/test/java/com/offbynull/actors/gateways/servlet/stores/redis/RedisStoreTest.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
| import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import com.offbynull.actors.shuttle.Message;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException; |
package com.offbynull.actors.gateways.servlet.stores.redis;
public class RedisStoreTest {
private RedisStore fixture;
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Before
public void before() {
// try (Jedis jedis = new Jedis("192.168.206.110", 6379)) {
// jedis.flushDB();
// }
// Connector connector = new JedisPoolConnector("192.168.206.110", 6379, 5);
| // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
// Path: redis-storage/src/test/java/com/offbynull/actors/gateways/servlet/stores/redis/RedisStoreTest.java
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import com.offbynull.actors.shuttle.Message;
import java.util.Arrays;
import java.util.List;
import org.junit.After;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
package com.offbynull.actors.gateways.servlet.stores.redis;
public class RedisStoreTest {
private RedisStore fixture;
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Before
public void before() {
// try (Jedis jedis = new Jedis("192.168.206.110", 6379)) {
// jedis.flushDB();
// }
// Connector connector = new JedisPoolConnector("192.168.206.110", 6379, 5);
| Connector connector = new TestConnector(); |
offbynull/actors | core/src/test/java/com/offbynull/actors/gateways/actor/RuleSetTest.java | // Path: core/src/main/java/com/offbynull/actors/gateways/actor/RuleSet.java
// public enum AccessType {
// /**
// * Access should be allowed.
// */
// ALLOW,
// /**
// * Access should be blocked.
// */
// REJECT
// }
| import com.offbynull.actors.gateways.actor.RuleSet.AccessType;
import com.offbynull.actors.address.Address;
import org.junit.Test;
import static org.junit.Assert.*; | package com.offbynull.actors.gateways.actor;
public class RuleSetTest {
private RuleSet fixture = new RuleSet();
@Test
public void mustRejectByDefault() {
assertEquals( | // Path: core/src/main/java/com/offbynull/actors/gateways/actor/RuleSet.java
// public enum AccessType {
// /**
// * Access should be allowed.
// */
// ALLOW,
// /**
// * Access should be blocked.
// */
// REJECT
// }
// Path: core/src/test/java/com/offbynull/actors/gateways/actor/RuleSetTest.java
import com.offbynull.actors.gateways.actor.RuleSet.AccessType;
import com.offbynull.actors.address.Address;
import org.junit.Test;
import static org.junit.Assert.*;
package com.offbynull.actors.gateways.actor;
public class RuleSetTest {
private RuleSet fixture = new RuleSet();
@Test
public void mustRejectByDefault() {
assertEquals( | AccessType.REJECT, |
offbynull/actors | redis-storage/src/test/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueueTest.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
| import com.offbynull.actors.redisclient.Connection;
import static com.offbynull.actors.address.Address.fromString;
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import org.junit.After;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Before;
import org.junit.Test; | package com.offbynull.actors.gateways.actor.stores.redis;
public final class TimestampQueueTest {
private Connector connector;
private Connection connection;
@Before
public void setUp() throws Exception {
// connector = new JedisPoolConnector("192.168.56.101", 6379, 1);
// clientFactory = new ConnectorClientFactory(connector); | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
// Path: redis-storage/src/test/java/com/offbynull/actors/gateways/actor/stores/redis/TimestampQueueTest.java
import com.offbynull.actors.redisclient.Connection;
import static com.offbynull.actors.address.Address.fromString;
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import org.junit.After;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Before;
import org.junit.Test;
package com.offbynull.actors.gateways.actor.stores.redis;
public final class TimestampQueueTest {
private Connector connector;
private Connection connection;
@Before
public void setUp() throws Exception {
// connector = new JedisPoolConnector("192.168.56.101", 6379, 1);
// clientFactory = new ConnectorClientFactory(connector); | connector = new TestConnector(); |
offbynull/actors | core/src/main/java/com/offbynull/actors/shuttles/pump/PumpShuttleController.java | // Path: core/src/main/java/com/offbynull/actors/shuttle/Shuttle.java
// public interface Shuttle {
// /**
// * Address prefix this shuttle is for.
// * @return address prefix
// */
// String getPrefix();
// /**
// * Sends {@link Message}s to the specific actor or gateway this {@link Shuttle} is for. Each message's destination
// * address must contain the same prefix as that returned by {@link #getPrefix() }, otherwise that message will be silently discarded.
// * @param messages messages to send
// * @throws NullPointerException if any argument is {@code null} or contains {@code null}
// */
// void send(Collection<Message> messages);
//
// /**
// * Sends a {@link Message} to the specific actor or gateway this {@link Shuttle} is for. Equivalent to calling
// * {@code send(Collections.singleton(message))}.
// * @param message message to send
// * @throws NullPointerException if any argument is {@code null}
// */
// default void send(Message message) {
// send(Collections.singleton(message));
// }
// }
| import com.offbynull.actors.shuttle.Message;
import com.offbynull.actors.shuttle.Shuttle;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; | /*
* Copyright (c) 2017, Kasra Faghihi, All rights reserved.
*
* 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 3.0 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.
*/
package com.offbynull.actors.shuttles.pump;
/**
* Controls a {@link PumpShuttle}.
* @author Kasra Faghihi
*/
public final class PumpShuttleController implements Closeable {
private static final Logger LOG = LoggerFactory.getLogger(PumpShuttleController.class);
private final LinkedBlockingQueue<Collection<Message>> queue;
private final PumpShuttle pumpShuttle; | // Path: core/src/main/java/com/offbynull/actors/shuttle/Shuttle.java
// public interface Shuttle {
// /**
// * Address prefix this shuttle is for.
// * @return address prefix
// */
// String getPrefix();
// /**
// * Sends {@link Message}s to the specific actor or gateway this {@link Shuttle} is for. Each message's destination
// * address must contain the same prefix as that returned by {@link #getPrefix() }, otherwise that message will be silently discarded.
// * @param messages messages to send
// * @throws NullPointerException if any argument is {@code null} or contains {@code null}
// */
// void send(Collection<Message> messages);
//
// /**
// * Sends a {@link Message} to the specific actor or gateway this {@link Shuttle} is for. Equivalent to calling
// * {@code send(Collections.singleton(message))}.
// * @param message message to send
// * @throws NullPointerException if any argument is {@code null}
// */
// default void send(Message message) {
// send(Collections.singleton(message));
// }
// }
// Path: core/src/main/java/com/offbynull/actors/shuttles/pump/PumpShuttleController.java
import com.offbynull.actors.shuttle.Message;
import com.offbynull.actors.shuttle.Shuttle;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/*
* Copyright (c) 2017, Kasra Faghihi, All rights reserved.
*
* 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 3.0 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.
*/
package com.offbynull.actors.shuttles.pump;
/**
* Controls a {@link PumpShuttle}.
* @author Kasra Faghihi
*/
public final class PumpShuttleController implements Closeable {
private static final Logger LOG = LoggerFactory.getLogger(PumpShuttleController.class);
private final LinkedBlockingQueue<Collection<Message>> queue;
private final PumpShuttle pumpShuttle; | private final Shuttle backingShuttle; |
offbynull/actors | redis-storage/src/test/java/com/offbynull/actors/gateways/actor/stores/redis/ActorAccessorTest.java | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
| import com.offbynull.actors.gateways.actor.stores.redis.ActorAccessor.Work;
import com.offbynull.actors.redisclient.Connection;
import static com.offbynull.actors.address.Address.fromString;
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import org.junit.After;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertNull;
import org.junit.Before;
import org.junit.Test; | package com.offbynull.actors.gateways.actor.stores.redis;
public final class ActorAccessorTest {
private Connector connector;
private Connection connection;
@Before
public void setUp() throws Exception {
// connector = new JedisPoolConnector("192.168.56.101", 6379, 1);
// clientFactory = new ConnectorClientFactory(connector); | // Path: redis-storage/src/main/java/com/offbynull/actors/redisclient/Connector.java
// public interface Connector extends Closeable {
// /**
// * Get a {@link Connection}.
// * @return connection
// * @throws IllegalStateException if closed
// */
// Connection getConnection();
// }
//
// Path: redis-storage/src/main/java/com/offbynull/actors/redisclients/test/TestConnector.java
// public final class TestConnector implements Connector {
//
// private final Map<String, Item> keyspace = new HashMap<>();
// private final AtomicBoolean closed = new AtomicBoolean();
//
// @Override
// public Connection getConnection() {
// Validate.validState(!closed.get(), "Closed");
// return new TestConnection(keyspace, closed);
// }
//
// @Override
// public void close() throws IOException {
// closed.set(true);
// }
//
// }
// Path: redis-storage/src/test/java/com/offbynull/actors/gateways/actor/stores/redis/ActorAccessorTest.java
import com.offbynull.actors.gateways.actor.stores.redis.ActorAccessor.Work;
import com.offbynull.actors.redisclient.Connection;
import static com.offbynull.actors.address.Address.fromString;
import com.offbynull.actors.redisclient.Connector;
import com.offbynull.actors.redisclients.test.TestConnector;
import org.junit.After;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertNull;
import org.junit.Before;
import org.junit.Test;
package com.offbynull.actors.gateways.actor.stores.redis;
public final class ActorAccessorTest {
private Connector connector;
private Connection connection;
@Before
public void setUp() throws Exception {
// connector = new JedisPoolConnector("192.168.56.101", 6379, 1);
// clientFactory = new ConnectorClientFactory(connector); | connector = new TestConnector(); |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/DashJoinedNamer.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/Strings.java
// public class Strings {
//
// /**
// * Fixes case of a word: Str - str, but URL - URL.
// * @param s Word to be fixed
// * @return all-lowercase or all-uppercase word.
// */
// public static String fixCase(String s) {
// if (s == null || s.length() == 0) {
// return s;
// }
// if ( Character.isUpperCase(s.charAt(0))
// && (s.length() == 1 || Character.isLowerCase(s.charAt(1)))) {
// s = s.toLowerCase();
// }
// return s;
// }
//
// /**
// * Generic string joining function.
// * @param strings Strings to be joined
// * @param fixCase does it need to fix word case
// * @param withChar char to join strings with.
// * @return joined-string
// */
// public static String joinStrings(List<String> strings, boolean fixCase, char withChar) {
// if (strings == null || strings.size() == 0) {
// return "";
// }
// StringBuilder result = null;
// for (String s : strings) {
// if (fixCase) {
// s = fixCase(s);
// }
// if (result == null) {
// result = new StringBuilder(s);
// } else {
// result.append(withChar);
// result.append(s);
// }
// }
// return result.toString();
// }
//
// /**
// * Rather clever function. Splits javaCaseIdentifier into parts
// * (java, Case, Identifier).
// * @param string String to be splitted
// * @return List of components
// */
// public static List<String> splitJavaIdentifier(String string) {
// assert string != null;
// List<String> result = new ArrayList<String>();
//
// int startIndex = 0;
// while (startIndex < string.length()) {
// if (Character.isLowerCase(string.charAt(startIndex))) {
// int i = startIndex;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else if (Character.isUpperCase(string.charAt(startIndex))) {
// if (string.length() - startIndex == 1) {
// result.add(Character.toString(string.charAt(startIndex++)));
// } else if (Character.isLowerCase(string.charAt(startIndex + 1))) {
// int i = startIndex + 1;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else { // if there's several uppercase letters in row
// int i = startIndex + 1;
// while (i < string.length() && Character.isUpperCase(string.charAt(i))
// && (string.length()-i == 1 || Character.isUpperCase(string.charAt(i+1)))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// }
// }else {
// result.add(Character.toString(string.charAt(startIndex++)));
// }
// }
// return result;
// }
//
// }
| import java.lang.reflect.Method;
import java.util.List;
import com.maxifier.cliche.util.Strings; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* Default "dash-joined" implementation of the CommandNamer.
*
* @author ASG
*/
public class DashJoinedNamer implements CommandNamer {
private final boolean doRemoveCommonPrefix;
public DashJoinedNamer(boolean doRemoveCommonPrefix) {
this.doRemoveCommonPrefix = doRemoveCommonPrefix;
}
public NamingInfo nameCommand(Method method) { | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/Strings.java
// public class Strings {
//
// /**
// * Fixes case of a word: Str - str, but URL - URL.
// * @param s Word to be fixed
// * @return all-lowercase or all-uppercase word.
// */
// public static String fixCase(String s) {
// if (s == null || s.length() == 0) {
// return s;
// }
// if ( Character.isUpperCase(s.charAt(0))
// && (s.length() == 1 || Character.isLowerCase(s.charAt(1)))) {
// s = s.toLowerCase();
// }
// return s;
// }
//
// /**
// * Generic string joining function.
// * @param strings Strings to be joined
// * @param fixCase does it need to fix word case
// * @param withChar char to join strings with.
// * @return joined-string
// */
// public static String joinStrings(List<String> strings, boolean fixCase, char withChar) {
// if (strings == null || strings.size() == 0) {
// return "";
// }
// StringBuilder result = null;
// for (String s : strings) {
// if (fixCase) {
// s = fixCase(s);
// }
// if (result == null) {
// result = new StringBuilder(s);
// } else {
// result.append(withChar);
// result.append(s);
// }
// }
// return result.toString();
// }
//
// /**
// * Rather clever function. Splits javaCaseIdentifier into parts
// * (java, Case, Identifier).
// * @param string String to be splitted
// * @return List of components
// */
// public static List<String> splitJavaIdentifier(String string) {
// assert string != null;
// List<String> result = new ArrayList<String>();
//
// int startIndex = 0;
// while (startIndex < string.length()) {
// if (Character.isLowerCase(string.charAt(startIndex))) {
// int i = startIndex;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else if (Character.isUpperCase(string.charAt(startIndex))) {
// if (string.length() - startIndex == 1) {
// result.add(Character.toString(string.charAt(startIndex++)));
// } else if (Character.isLowerCase(string.charAt(startIndex + 1))) {
// int i = startIndex + 1;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else { // if there's several uppercase letters in row
// int i = startIndex + 1;
// while (i < string.length() && Character.isUpperCase(string.charAt(i))
// && (string.length()-i == 1 || Character.isUpperCase(string.charAt(i+1)))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// }
// }else {
// result.add(Character.toString(string.charAt(startIndex++)));
// }
// }
// return result;
// }
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/DashJoinedNamer.java
import java.lang.reflect.Method;
import java.util.List;
import com.maxifier.cliche.util.Strings;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* Default "dash-joined" implementation of the CommandNamer.
*
* @author ASG
*/
public class DashJoinedNamer implements CommandNamer {
private final boolean doRemoveCommonPrefix;
public DashJoinedNamer(boolean doRemoveCommonPrefix) {
this.doRemoveCommonPrefix = doRemoveCommonPrefix;
}
public NamingInfo nameCommand(Method method) { | List<String> words = Strings.splitJavaIdentifier(method.getName()); |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/ConsoleIO.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/Strings.java
// public class Strings {
//
// /**
// * Fixes case of a word: Str - str, but URL - URL.
// * @param s Word to be fixed
// * @return all-lowercase or all-uppercase word.
// */
// public static String fixCase(String s) {
// if (s == null || s.length() == 0) {
// return s;
// }
// if ( Character.isUpperCase(s.charAt(0))
// && (s.length() == 1 || Character.isLowerCase(s.charAt(1)))) {
// s = s.toLowerCase();
// }
// return s;
// }
//
// /**
// * Generic string joining function.
// * @param strings Strings to be joined
// * @param fixCase does it need to fix word case
// * @param withChar char to join strings with.
// * @return joined-string
// */
// public static String joinStrings(List<String> strings, boolean fixCase, char withChar) {
// if (strings == null || strings.size() == 0) {
// return "";
// }
// StringBuilder result = null;
// for (String s : strings) {
// if (fixCase) {
// s = fixCase(s);
// }
// if (result == null) {
// result = new StringBuilder(s);
// } else {
// result.append(withChar);
// result.append(s);
// }
// }
// return result.toString();
// }
//
// /**
// * Rather clever function. Splits javaCaseIdentifier into parts
// * (java, Case, Identifier).
// * @param string String to be splitted
// * @return List of components
// */
// public static List<String> splitJavaIdentifier(String string) {
// assert string != null;
// List<String> result = new ArrayList<String>();
//
// int startIndex = 0;
// while (startIndex < string.length()) {
// if (Character.isLowerCase(string.charAt(startIndex))) {
// int i = startIndex;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else if (Character.isUpperCase(string.charAt(startIndex))) {
// if (string.length() - startIndex == 1) {
// result.add(Character.toString(string.charAt(startIndex++)));
// } else if (Character.isLowerCase(string.charAt(startIndex + 1))) {
// int i = startIndex + 1;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else { // if there's several uppercase letters in row
// int i = startIndex + 1;
// while (i < string.length() && Character.isUpperCase(string.charAt(i))
// && (string.length()-i == 1 || Character.isUpperCase(string.charAt(i+1)))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// }
// }else {
// result.add(Character.toString(string.charAt(startIndex++)));
// }
// }
// return result;
// }
//
// }
| import com.maxifier.cliche.util.Strings;
import jline.console.ConsoleReader;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.List; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* Console IO subsystem.
* This is also one of special command handlers and is responsible
* for logging (duplicating output) and execution of scripts.
*
* @author ASG
*/
public class ConsoleIO implements Input, Output, ShellManageable {
public ConsoleIO(ConsoleReader in, PrintStream out, PrintStream err) {
this.in = in;
this.out = out;
this.err = err;
}
public ConsoleIO() throws IOException {
this(new ConsoleReader(System.in, System.out),
System.out, System.err);
}
private ConsoleReader in;
private PrintStream out;
private PrintStream err;
private int lastCommandOffset = 0;
public String readCommand(List<String> path) {
try { | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/Strings.java
// public class Strings {
//
// /**
// * Fixes case of a word: Str - str, but URL - URL.
// * @param s Word to be fixed
// * @return all-lowercase or all-uppercase word.
// */
// public static String fixCase(String s) {
// if (s == null || s.length() == 0) {
// return s;
// }
// if ( Character.isUpperCase(s.charAt(0))
// && (s.length() == 1 || Character.isLowerCase(s.charAt(1)))) {
// s = s.toLowerCase();
// }
// return s;
// }
//
// /**
// * Generic string joining function.
// * @param strings Strings to be joined
// * @param fixCase does it need to fix word case
// * @param withChar char to join strings with.
// * @return joined-string
// */
// public static String joinStrings(List<String> strings, boolean fixCase, char withChar) {
// if (strings == null || strings.size() == 0) {
// return "";
// }
// StringBuilder result = null;
// for (String s : strings) {
// if (fixCase) {
// s = fixCase(s);
// }
// if (result == null) {
// result = new StringBuilder(s);
// } else {
// result.append(withChar);
// result.append(s);
// }
// }
// return result.toString();
// }
//
// /**
// * Rather clever function. Splits javaCaseIdentifier into parts
// * (java, Case, Identifier).
// * @param string String to be splitted
// * @return List of components
// */
// public static List<String> splitJavaIdentifier(String string) {
// assert string != null;
// List<String> result = new ArrayList<String>();
//
// int startIndex = 0;
// while (startIndex < string.length()) {
// if (Character.isLowerCase(string.charAt(startIndex))) {
// int i = startIndex;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else if (Character.isUpperCase(string.charAt(startIndex))) {
// if (string.length() - startIndex == 1) {
// result.add(Character.toString(string.charAt(startIndex++)));
// } else if (Character.isLowerCase(string.charAt(startIndex + 1))) {
// int i = startIndex + 1;
// while (i < string.length() && Character.isLowerCase(string.charAt(i))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// } else { // if there's several uppercase letters in row
// int i = startIndex + 1;
// while (i < string.length() && Character.isUpperCase(string.charAt(i))
// && (string.length()-i == 1 || Character.isUpperCase(string.charAt(i+1)))) {
// i++;
// }
// result.add(string.substring(startIndex, i));
// startIndex = i;
// }
// }else {
// result.add(Character.toString(string.charAt(startIndex++)));
// }
// }
// return result;
// }
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/ConsoleIO.java
import com.maxifier.cliche.util.Strings;
import jline.console.ConsoleReader;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.List;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* Console IO subsystem.
* This is also one of special command handlers and is responsible
* for logging (duplicating output) and execution of scripts.
*
* @author ASG
*/
public class ConsoleIO implements Input, Output, ShellManageable {
public ConsoleIO(ConsoleReader in, PrintStream out, PrintStream err) {
this.in = in;
this.out = out;
this.err = err;
}
public ConsoleIO() throws IOException {
this(new ConsoleReader(System.in, System.out),
System.out, System.err);
}
private ConsoleReader in;
private PrintStream out;
private PrintStream err;
private int lastCommandOffset = 0;
public String readCommand(List<String> path) {
try { | String prompt = Strings.joinStrings(path, false, '/'); |
maxifier/cliche-shell | cliche-shell-core/src/test/java/com/maxifier/cliche/DashJoinedNamerTest.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/CommandNamer.java
// public static class NamingInfo {
// public final String commandName;
// public final String[] possibleAbbreviations;
//
// public NamingInfo(String commandName, String[] possibleAbbreviations) {
// this.commandName = commandName;
// this.possibleAbbreviations = possibleAbbreviations;
// }
//
// @Override
// public boolean equals(Object obj) {
// if (obj == null) {
// return false;
// }
// if (getClass() != obj.getClass()) {
// return false;
// }
// final NamingInfo other = (NamingInfo)obj;
// if ((this.commandName == null) ? (other.commandName != null) : !this.commandName.equals(other.commandName)) {
// return false;
// }
// if (this.possibleAbbreviations != other.possibleAbbreviations &&
// (this.possibleAbbreviations == null ||
// !Arrays.equals(this.possibleAbbreviations, other.possibleAbbreviations))) {
// return false;
// }
// return true;
// }
//
// @Override
// public int hashCode() {
// int hash = 5;
// hash = 59 * hash + (this.commandName != null ? this.commandName.hashCode() : 0);
// hash = 59 * hash + (this.possibleAbbreviations != null ? Arrays.hashCode(this.possibleAbbreviations) : 0);
// return hash;
// }
//
// @Override
// public String toString() {
// return String.format("NamingInfo(%s, %s)", commandName, Arrays.toString(possibleAbbreviations));
// }
// }
| import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import com.maxifier.cliche.CommandNamer.NamingInfo;
import org.junit.Test;
import java.lang.reflect.Method; | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.maxifier.cliche;
/**
*
* @author ASG
*/
public class DashJoinedNamerTest {
public DashJoinedNamerTest() {
}
private static class TestClass{
@Command
public void cliTestMethod1() { }
@Command
public void cmdTestMethod2() { }
}
@Test
public void testNameCommand() throws NoSuchMethodException {
System.out.println("nameCommand");
CommandNamer namer = new DashJoinedNamer(true);
Method[] methods = new Method[] {
TestClass.class.getMethod("cliTestMethod1"),
TestClass.class.getMethod("cmdTestMethod2"),
};
| // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/CommandNamer.java
// public static class NamingInfo {
// public final String commandName;
// public final String[] possibleAbbreviations;
//
// public NamingInfo(String commandName, String[] possibleAbbreviations) {
// this.commandName = commandName;
// this.possibleAbbreviations = possibleAbbreviations;
// }
//
// @Override
// public boolean equals(Object obj) {
// if (obj == null) {
// return false;
// }
// if (getClass() != obj.getClass()) {
// return false;
// }
// final NamingInfo other = (NamingInfo)obj;
// if ((this.commandName == null) ? (other.commandName != null) : !this.commandName.equals(other.commandName)) {
// return false;
// }
// if (this.possibleAbbreviations != other.possibleAbbreviations &&
// (this.possibleAbbreviations == null ||
// !Arrays.equals(this.possibleAbbreviations, other.possibleAbbreviations))) {
// return false;
// }
// return true;
// }
//
// @Override
// public int hashCode() {
// int hash = 5;
// hash = 59 * hash + (this.commandName != null ? this.commandName.hashCode() : 0);
// hash = 59 * hash + (this.possibleAbbreviations != null ? Arrays.hashCode(this.possibleAbbreviations) : 0);
// return hash;
// }
//
// @Override
// public String toString() {
// return String.format("NamingInfo(%s, %s)", commandName, Arrays.toString(possibleAbbreviations));
// }
// }
// Path: cliche-shell-core/src/test/java/com/maxifier/cliche/DashJoinedNamerTest.java
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import com.maxifier.cliche.CommandNamer.NamingInfo;
import org.junit.Test;
import java.lang.reflect.Method;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.maxifier.cliche;
/**
*
* @author ASG
*/
public class DashJoinedNamerTest {
public DashJoinedNamerTest() {
}
private static class TestClass{
@Command
public void cliTestMethod1() { }
@Command
public void cmdTestMethod2() { }
}
@Test
public void testNameCommand() throws NoSuchMethodException {
System.out.println("nameCommand");
CommandNamer namer = new DashJoinedNamer(true);
Method[] methods = new Method[] {
TestClass.class.getMethod("cliTestMethod1"),
TestClass.class.getMethod("cmdTestMethod2"),
};
| CommandNamer.NamingInfo[] expecteds = new CommandNamer.NamingInfo[] { |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/SshNonInteractiveShellCommand.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
| import com.maxifier.cliche.util.EmptyMultiMap;
import jline.console.ConsoleReader;
import jline.console.completer.AggregateCompleter;
import jline.console.completer.StringsCompleter;
import jline.console.history.FileHistory;
import jline.console.history.History;
import jline.console.history.PersistentHistory;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Future; | this.in = in;
}
@Override
public void setOutputStream(OutputStream out) {
this.out = new PrintStream(new TtyFilterOutputStream(out));
}
@Override
public void setErrorStream(OutputStream err) {
this.err = new PrintStream(err);
}
@Override
public void setExitCallback(ExitCallback callback) {
this.callback = callback;
}
@Override
public void start(Environment env) throws IOException {
try {
consoleReader = new ConsoleReader(in, out);
consoleReader.setBellEnabled(true);
consoleReader.setHistory(new FileHistory(new File(System.getProperty("user.home"), ".clhistory")));
consoleReader.setHistoryEnabled(true);
consoleReader.setExpandEvents(false);
ConsoleIO io = new ConsoleIO(consoleReader, out, out);
List<String> path = new ArrayList<String>(1);
path.add(""); | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/SshNonInteractiveShellCommand.java
import com.maxifier.cliche.util.EmptyMultiMap;
import jline.console.ConsoleReader;
import jline.console.completer.AggregateCompleter;
import jline.console.completer.StringsCompleter;
import jline.console.history.FileHistory;
import jline.console.history.History;
import jline.console.history.PersistentHistory;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Future;
this.in = in;
}
@Override
public void setOutputStream(OutputStream out) {
this.out = new PrintStream(new TtyFilterOutputStream(out));
}
@Override
public void setErrorStream(OutputStream err) {
this.err = new PrintStream(err);
}
@Override
public void setExitCallback(ExitCallback callback) {
this.callback = callback;
}
@Override
public void start(Environment env) throws IOException {
try {
consoleReader = new ConsoleReader(in, out);
consoleReader.setBellEnabled(true);
consoleReader.setHistory(new FileHistory(new File(System.getProperty("user.home"), ".clhistory")));
consoleReader.setHistoryEnabled(true);
consoleReader.setExpandEvents(false);
ConsoleIO io = new ConsoleIO(consoleReader, out, out);
List<String> path = new ArrayList<String>(1);
path.add(""); | Shell theShell = new Shell(new Shell.Settings(io, io, new EmptyMultiMap(), false), |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
| import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* @author ASG
*/
public class ShellFactory {
private ShellFactory() {
} // this class has only static methods.
/**
* One of facade methods for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param handlers Command handlers
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object... handlers) throws IOException {
ConsoleIO io = new ConsoleIO();
List<String> path = new ArrayList<String>(1);
path.add(prompt);
| // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java
import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* @author ASG
*/
public class ShellFactory {
private ShellFactory() {
} // this class has only static methods.
/**
* One of facade methods for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param handlers Command handlers
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object... handlers) throws IOException {
ConsoleIO io = new ConsoleIO();
List<String> path = new ArrayList<String>(1);
path.add(prompt);
| MultiMap<String, Object> modifAuxHandlers = new ArrayHashMultiMap<String, Object>(); |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
| import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* @author ASG
*/
public class ShellFactory {
private ShellFactory() {
} // this class has only static methods.
/**
* One of facade methods for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param handlers Command handlers
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object... handlers) throws IOException {
ConsoleIO io = new ConsoleIO();
List<String> path = new ArrayList<String>(1);
path.add(prompt);
| // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java
import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
package com.maxifier.cliche;
/**
* @author ASG
*/
public class ShellFactory {
private ShellFactory() {
} // this class has only static methods.
/**
* One of facade methods for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param handlers Command handlers
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object... handlers) throws IOException {
ConsoleIO io = new ConsoleIO();
List<String> path = new ArrayList<String>(1);
path.add(prompt);
| MultiMap<String, Object> modifAuxHandlers = new ArrayHashMultiMap<String, Object>(); |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
| import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; |
List<String> path = new ArrayList<String>(1);
path.add(prompt);
MultiMap<String, Object> modifAuxHandlers = new ArrayHashMultiMap<String, Object>(auxHandlers);
modifAuxHandlers.put("!", io);
Shell theShell = new Shell(new Shell.Settings(io, io, modifAuxHandlers, false),
new CommandTable(new DashJoinedNamer(true)), path);
theShell.setAppName(appName);
theShell.addMainHandler(theShell, "!");
theShell.addMainHandler(new HelpCommandHandler(), "?");
theShell.addMainHandler(mainHandler, "");
return theShell;
}
/**
* Facade method for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param mainHandler Command handler
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object mainHandler) throws IOException { | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/ShellFactory.java
import com.google.common.collect.Lists;
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.EmptyMultiMap;
import com.maxifier.cliche.util.MultiMap;
import jline.console.ConsoleReader;
import org.apache.sshd.SshServer;
import org.apache.sshd.common.Factory;
import org.apache.sshd.server.Command;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
List<String> path = new ArrayList<String>(1);
path.add(prompt);
MultiMap<String, Object> modifAuxHandlers = new ArrayHashMultiMap<String, Object>(auxHandlers);
modifAuxHandlers.put("!", io);
Shell theShell = new Shell(new Shell.Settings(io, io, modifAuxHandlers, false),
new CommandTable(new DashJoinedNamer(true)), path);
theShell.setAppName(appName);
theShell.addMainHandler(theShell, "!");
theShell.addMainHandler(new HelpCommandHandler(), "?");
theShell.addMainHandler(mainHandler, "");
return theShell;
}
/**
* Facade method for operating the Shell.
*
* Run the obtained Shell with commandLoop().
*
* @param prompt Prompt to be displayed
* @param appName The app name string
* @param mainHandler Command handler
* @return Shell that can be either further customized or run directly by calling commandLoop().
* @throws IOException
*/
public static Shell createConsoleShell(String prompt, String appName, Object mainHandler) throws IOException { | return createConsoleShell(prompt, appName, mainHandler, new EmptyMultiMap<String, Object>()); |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/SshShellCommand.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
| import com.maxifier.cliche.util.EmptyMultiMap;
import jline.console.ConsoleReader;
import jline.console.completer.AggregateCompleter;
import jline.console.completer.StringsCompleter;
import jline.console.history.FileHistory;
import jline.console.history.History;
import jline.console.history.PersistentHistory;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
import java.io.File;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future; | this.out = new PrintStream(new TtyFilterOutputStream(out));
}
@Override
public void setErrorStream(OutputStream err) {
this.err = new PrintStream(err);
}
@Override
public void setExitCallback(ExitCallback callback) {
this.callback = callback;
}
@Override
public void start(Environment env) throws IOException {
this.future = executor.submit(new Runnable() {
@Override
public void run() {
try {
consoleReader = new ConsoleReader(in, out);
consoleReader.setBellEnabled(true);
//history file is port based to separate apps
File historyFile = new File(System.getProperty("user.home"), ".clhistory" + port);
consoleReader.setHistory(new FileHistory(historyFile));
consoleReader.setHistoryEnabled(true);
consoleReader.setExpandEvents(false);
ConsoleIO io = new ConsoleIO(consoleReader, out, out);
List<String> path = new ArrayList<String>(1);
path.add(promt); | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/EmptyMultiMap.java
// public class EmptyMultiMap<K, V> implements MultiMap<K, V> {
//
// public void put(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public Collection<V> get(K key) {
// return new ArrayList<V>();
// }
//
// public Set<K> keySet() {
// return new HashSet<K>();
// }
//
// public void remove(K key, V value) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public void removeAll(K key) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// public int size() {
// return 0;
// }
//
// public void putAll(MultiMap<K, V> map) {
// throw new UnsupportedOperationException("You can't modify EmptyMultyMap: it's always empty!");
// }
//
// @Override
// public String toString() {
// return "{}";
// }
//
//
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/SshShellCommand.java
import com.maxifier.cliche.util.EmptyMultiMap;
import jline.console.ConsoleReader;
import jline.console.completer.AggregateCompleter;
import jline.console.completer.StringsCompleter;
import jline.console.history.FileHistory;
import jline.console.history.History;
import jline.console.history.PersistentHistory;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.Environment;
import org.apache.sshd.server.ExitCallback;
import java.io.File;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
this.out = new PrintStream(new TtyFilterOutputStream(out));
}
@Override
public void setErrorStream(OutputStream err) {
this.err = new PrintStream(err);
}
@Override
public void setExitCallback(ExitCallback callback) {
this.callback = callback;
}
@Override
public void start(Environment env) throws IOException {
this.future = executor.submit(new Runnable() {
@Override
public void run() {
try {
consoleReader = new ConsoleReader(in, out);
consoleReader.setBellEnabled(true);
//history file is port based to separate apps
File historyFile = new File(System.getProperty("user.home"), ".clhistory" + port);
consoleReader.setHistory(new FileHistory(historyFile));
consoleReader.setHistoryEnabled(true);
consoleReader.setExpandEvents(false);
ConsoleIO io = new ConsoleIO(consoleReader, out, out);
List<String> path = new ArrayList<String>(1);
path.add(promt); | theShell = new Shell(new Shell.Settings(io, io, new EmptyMultiMap(), false), |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/Shell.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
| import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.MultiMap;
import com.google.common.base.Strings;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
/*
* Introducing the asg.cliche (http://cliche.sourceforge.net/)
* Cliche is to be a VERY simple reflection-based command line shell
* to provide simple CLI for simple applications.
* The name formed as follows: "CLI Shell" --> "CLIShe" --> "Cliche".
*/
package com.maxifier.cliche;
/**
* Shell is the class interacting with user.
* Provides the command loop.
* All logic lies here.
*
* @author ASG
*/
public class Shell {
public static String PROJECT_HOMEPAGE_URL = "http://cliche.sourceforge.net";
private Output output;
private Input input;
private String appName;
public static class Settings {
private final Input input;
private final Output output; | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/Shell.java
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.MultiMap;
import com.google.common.base.Strings;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
/*
* Introducing the asg.cliche (http://cliche.sourceforge.net/)
* Cliche is to be a VERY simple reflection-based command line shell
* to provide simple CLI for simple applications.
* The name formed as follows: "CLI Shell" --> "CLIShe" --> "Cliche".
*/
package com.maxifier.cliche;
/**
* Shell is the class interacting with user.
* Provides the command loop.
* All logic lies here.
*
* @author ASG
*/
public class Shell {
public static String PROJECT_HOMEPAGE_URL = "http://cliche.sourceforge.net";
private Output output;
private Input input;
private String appName;
public static class Settings {
private final Input input;
private final Output output; | private final MultiMap<String, Object> auxHandlers; |
maxifier/cliche-shell | cliche-shell-core/src/main/java/com/maxifier/cliche/Shell.java | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
| import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.MultiMap;
import com.google.common.base.Strings;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List; | /*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
/*
* Introducing the asg.cliche (http://cliche.sourceforge.net/)
* Cliche is to be a VERY simple reflection-based command line shell
* to provide simple CLI for simple applications.
* The name formed as follows: "CLI Shell" --> "CLIShe" --> "Cliche".
*/
package com.maxifier.cliche;
/**
* Shell is the class interacting with user.
* Provides the command loop.
* All logic lies here.
*
* @author ASG
*/
public class Shell {
public static String PROJECT_HOMEPAGE_URL = "http://cliche.sourceforge.net";
private Output output;
private Input input;
private String appName;
public static class Settings {
private final Input input;
private final Output output;
private final MultiMap<String, Object> auxHandlers;
private final boolean displayTime;
public Settings(Input input, Output output, MultiMap auxHandlers, boolean displayTime) {
this.input = input;
this.output = output;
this.auxHandlers = auxHandlers;
this.displayTime = displayTime;
}
public Settings createWithAddedAuxHandlers(MultiMap<String, Object> addAuxHandlers) { | // Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/ArrayHashMultiMap.java
// public final class ArrayHashMultiMap<K, V> implements MultiMap<K, V> {
//
// private Map<K, List<V>> listMap;
//
// public ArrayHashMultiMap() {
// listMap = new HashMap<K, List<V>>();
// }
//
// public ArrayHashMultiMap(MultiMap<K, V> map) {
// this();
// putAll(map);
// }
//
// public void put(K key, V value) {
// List<V> values = listMap.get(key);
// if (values == null) {
// values = new ArrayList<V>();
// listMap.put(key, values);
// }
// values.add(value);
// }
//
// public Collection<V> get(K key) {
// List<V> result = listMap.get(key);
// if (result == null) {
// result = new ArrayList<V>();
// }
// return result;
// }
//
// public Set<K> keySet() {
// return listMap.keySet();
// }
//
// public void remove(K key, V value) {
// List<V> values = listMap.get(key);
// if (values != null) {
// values.remove(value);
// if (values.isEmpty()) {
// listMap.remove(key);
// }
// }
// }
//
// public void removeAll(K key) {
// listMap.remove(key);
// }
//
// public int size() {
// int sum = 0;
// for (K key : listMap.keySet()) {
// sum += listMap.get(key).size();
// }
// return sum;
// }
//
// public void putAll(MultiMap<K, V> map) {
// for (K key : map.keySet()) {
// for (V val : map.get(key)) {
// put(key, val);
// }
// }
// }
//
// @Override
// public String toString() {
// return listMap.toString();
// }
//
//
//
// }
//
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/util/MultiMap.java
// public interface MultiMap<K, V> {
//
// void put(K key, V value);
//
// void putAll(MultiMap<K, V> map);
//
// Collection<V> get(K key);
//
// Set<K> keySet();
//
// void remove(K key, V value);
//
// void removeAll(K key);
//
// /**
// * @return total size of all value collections in the MultiMap.
// */
// int size();
//
// }
// Path: cliche-shell-core/src/main/java/com/maxifier/cliche/Shell.java
import com.maxifier.cliche.util.ArrayHashMultiMap;
import com.maxifier.cliche.util.MultiMap;
import com.google.common.base.Strings;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/*
* This file is part of the Cliche project, licensed under MIT License.
* See LICENSE.txt file in root folder of Cliche sources.
*/
/*
* Introducing the asg.cliche (http://cliche.sourceforge.net/)
* Cliche is to be a VERY simple reflection-based command line shell
* to provide simple CLI for simple applications.
* The name formed as follows: "CLI Shell" --> "CLIShe" --> "Cliche".
*/
package com.maxifier.cliche;
/**
* Shell is the class interacting with user.
* Provides the command loop.
* All logic lies here.
*
* @author ASG
*/
public class Shell {
public static String PROJECT_HOMEPAGE_URL = "http://cliche.sourceforge.net";
private Output output;
private Input input;
private String appName;
public static class Settings {
private final Input input;
private final Output output;
private final MultiMap<String, Object> auxHandlers;
private final boolean displayTime;
public Settings(Input input, Output output, MultiMap auxHandlers, boolean displayTime) {
this.input = input;
this.output = output;
this.auxHandlers = auxHandlers;
this.displayTime = displayTime;
}
public Settings createWithAddedAuxHandlers(MultiMap<String, Object> addAuxHandlers) { | MultiMap<String, Object> allAuxHandlers = new ArrayHashMultiMap<String, Object>(auxHandlers); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/NodeBean.java | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/nodenetwork/bean/NodeReportBean.java
// public class NodeReportBean {
// private String Hostname=null;
// private long totalMemory=0;
// private long freeMemory=0;
// private long totalSwapMemory=0;
// private long freeSwapMemory=0;
// private int cpuUsage=0;
// private int cpuCoreNum=0;
// private int cpuPower=0;
// private String ipAddr=null;
// private String macAddr=null;
// private double upTime=0;
// private boolean runningFlag=false;
// private String runningApplication=null;
// private String runningApplicationVersion=null;
// private String runningApplicationPath=null;
// public String getHostname() {
// return Hostname;
// }
// public void setHostname(String hostname) {
// Hostname = hostname;
// }
// public boolean isRunningFlag() {
// return runningFlag;
// }
// public void setRunningFlag(boolean runningFlag) {
// this.runningFlag = runningFlag;
// }
// public String getRunningApplication() {
// return runningApplication;
// }
// public void setRunningApplication(String runningApplication) {
// this.runningApplication = runningApplication;
// }
// public String getRunningApplicationVersion() {
// return runningApplicationVersion;
// }
//
// public String getRunningApplicationPath() {
// return runningApplicationPath;
// }
// public void setRunningApplicationPath(String runningApplicationPath) {
// this.runningApplicationPath = runningApplicationPath;
// }
// public long getTotalMemory() {
// return totalMemory;
// }
// public void setTotalMemory(long totalMemory) {
// this.totalMemory = totalMemory;
// }
// public long getFreeMemory() {
// return freeMemory;
// }
// public void setFreeMemory(long freeMemory) {
// this.freeMemory = freeMemory;
// }
// public long getTotalSwapMemory() {
// return totalSwapMemory;
// }
// public void setTotalSwapMemory(long totalSwapMemory) {
// this.totalSwapMemory = totalSwapMemory;
// }
// public long getFreeSwapMemory() {
// return freeSwapMemory;
// }
// public void setFreeSwapMemory(long freeSwapMemory) {
// this.freeSwapMemory = freeSwapMemory;
// }
// public int getCpuUsage() {
// return cpuUsage;
// }
// public void setCpuUsage(int cpuUsage) {
// this.cpuUsage = cpuUsage;
// }
// public int getCpuCoreNum() {
// return cpuCoreNum;
// }
// public void setCpuCoreNum(int cpuCoreNum) {
// this.cpuCoreNum = cpuCoreNum;
// }
// public int getCpuPower() {
// return cpuPower;
// }
// public void setCpuPower(int cpuPower) {
// this.cpuPower = cpuPower;
// }
// public String getIpAddr() {
// return ipAddr;
// }
// public void setIpAddr(String ipAddr) {
// this.ipAddr = ipAddr;
// }
// public String getMacAddr() {
// return macAddr;
// }
// public void setMacAddr(String macAddr) {
// this.macAddr = macAddr;
// }
// public double getUpTime() {
// return upTime;
// }
// public void setUpTime(double upTime) {
// this.upTime = upTime;
// }
// public void setRunningApplicationVersion(String runningApplicationVersion) {
// this.runningApplicationVersion = runningApplicationVersion;
// }
// }
| import org.apache.mina.core.session.IoSession;
import org.eclipse.jetty.continuation.Continuation;
import com.sysu.cloudgaminghub.hub.nodenetwork.bean.NodeReportBean; | package com.sysu.cloudgaminghub.hub;
public class NodeBean {
private String Hostname=null;
private IoSession session=null; | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/nodenetwork/bean/NodeReportBean.java
// public class NodeReportBean {
// private String Hostname=null;
// private long totalMemory=0;
// private long freeMemory=0;
// private long totalSwapMemory=0;
// private long freeSwapMemory=0;
// private int cpuUsage=0;
// private int cpuCoreNum=0;
// private int cpuPower=0;
// private String ipAddr=null;
// private String macAddr=null;
// private double upTime=0;
// private boolean runningFlag=false;
// private String runningApplication=null;
// private String runningApplicationVersion=null;
// private String runningApplicationPath=null;
// public String getHostname() {
// return Hostname;
// }
// public void setHostname(String hostname) {
// Hostname = hostname;
// }
// public boolean isRunningFlag() {
// return runningFlag;
// }
// public void setRunningFlag(boolean runningFlag) {
// this.runningFlag = runningFlag;
// }
// public String getRunningApplication() {
// return runningApplication;
// }
// public void setRunningApplication(String runningApplication) {
// this.runningApplication = runningApplication;
// }
// public String getRunningApplicationVersion() {
// return runningApplicationVersion;
// }
//
// public String getRunningApplicationPath() {
// return runningApplicationPath;
// }
// public void setRunningApplicationPath(String runningApplicationPath) {
// this.runningApplicationPath = runningApplicationPath;
// }
// public long getTotalMemory() {
// return totalMemory;
// }
// public void setTotalMemory(long totalMemory) {
// this.totalMemory = totalMemory;
// }
// public long getFreeMemory() {
// return freeMemory;
// }
// public void setFreeMemory(long freeMemory) {
// this.freeMemory = freeMemory;
// }
// public long getTotalSwapMemory() {
// return totalSwapMemory;
// }
// public void setTotalSwapMemory(long totalSwapMemory) {
// this.totalSwapMemory = totalSwapMemory;
// }
// public long getFreeSwapMemory() {
// return freeSwapMemory;
// }
// public void setFreeSwapMemory(long freeSwapMemory) {
// this.freeSwapMemory = freeSwapMemory;
// }
// public int getCpuUsage() {
// return cpuUsage;
// }
// public void setCpuUsage(int cpuUsage) {
// this.cpuUsage = cpuUsage;
// }
// public int getCpuCoreNum() {
// return cpuCoreNum;
// }
// public void setCpuCoreNum(int cpuCoreNum) {
// this.cpuCoreNum = cpuCoreNum;
// }
// public int getCpuPower() {
// return cpuPower;
// }
// public void setCpuPower(int cpuPower) {
// this.cpuPower = cpuPower;
// }
// public String getIpAddr() {
// return ipAddr;
// }
// public void setIpAddr(String ipAddr) {
// this.ipAddr = ipAddr;
// }
// public String getMacAddr() {
// return macAddr;
// }
// public void setMacAddr(String macAddr) {
// this.macAddr = macAddr;
// }
// public double getUpTime() {
// return upTime;
// }
// public void setUpTime(double upTime) {
// this.upTime = upTime;
// }
// public void setRunningApplicationVersion(String runningApplicationVersion) {
// this.runningApplicationVersion = runningApplicationVersion;
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/NodeBean.java
import org.apache.mina.core.session.IoSession;
import org.eclipse.jetty.continuation.Continuation;
import com.sysu.cloudgaminghub.hub.nodenetwork.bean.NodeReportBean;
package com.sysu.cloudgaminghub.hub;
public class NodeBean {
private String Hostname=null;
private IoSession session=null; | private NodeReportBean reportBean=null; |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/CloudGamingProvider.java | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
| import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.quigley.zabbixj.metrics.MetricsException;
import com.quigley.zabbixj.metrics.MetricsKey;
import com.quigley.zabbixj.metrics.MetricsProvider;
import com.sysu.cloudgaming.config.Config; | package com.sysu.cloudgaming.node;
public class CloudGamingProvider implements MetricsProvider{
private static Logger logger = LoggerFactory.getLogger(ZabbixClient.class);
@Override
public Object getValue(MetricsKey arg0) throws MetricsException {
//System.out.println(arg0.getKey());
if(arg0.getKey().equals("ApplicationVer"))
{ | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/CloudGamingProvider.java
import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.quigley.zabbixj.metrics.MetricsException;
import com.quigley.zabbixj.metrics.MetricsKey;
import com.quigley.zabbixj.metrics.MetricsProvider;
import com.sysu.cloudgaming.config.Config;
package com.sysu.cloudgaming.node;
public class CloudGamingProvider implements MetricsProvider{
private static Logger logger = LoggerFactory.getLogger(ZabbixClient.class);
@Override
public Object getValue(MetricsKey arg0) throws MetricsException {
//System.out.println(arg0.getKey());
if(arg0.getKey().equals("ApplicationVer"))
{ | return Config.VERSION; |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/stun/StunServer.java | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
| import java.net.InetSocketAddress;
import org.apache.mina.transport.socket.nio.NioDatagramAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config; | package com.sysu.cloudgaminghub.stun;
public class StunServer {
private static Logger logger = LoggerFactory.getLogger(StunServer.class);
NioDatagramAcceptor acceptor=null;
public boolean startStunServer()
{
acceptor = new NioDatagramAcceptor();
acceptor.setHandler(new StunHandler());
acceptor.getSessionConfig().setReuseAddress(true);
try
{ | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
// Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/stun/StunServer.java
import java.net.InetSocketAddress;
import org.apache.mina.transport.socket.nio.NioDatagramAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config;
package com.sysu.cloudgaminghub.stun;
public class StunServer {
private static Logger logger = LoggerFactory.getLogger(StunServer.class);
NioDatagramAcceptor acceptor=null;
public boolean startStunServer()
{
acceptor = new NioDatagramAcceptor();
acceptor.setHandler(new StunHandler());
acceptor.getSessionConfig().setReuseAddress(true);
try
{ | acceptor.bind(new InetSocketAddress(Config.STUNPORT)); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/network/NodeNetwork.java | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
| import java.net.InetSocketAddress;
import org.apache.mina.core.future.CloseFuture;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.future.IoFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config; | package com.sysu.cloudgaming.node.network;
public class NodeNetwork {
NioSocketConnector connector=null;
private static Logger logger = LoggerFactory.getLogger(NodeNetwork.class);
private IoSession session=null;
public IoSession getNetworkSession()
{
return this.session;
}
public boolean setupNodeNetwork()
{
connector = new NioSocketConnector();
| // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/network/NodeNetwork.java
import java.net.InetSocketAddress;
import org.apache.mina.core.future.CloseFuture;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.future.IoFuture;
import org.apache.mina.core.future.IoFutureListener;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config;
package com.sysu.cloudgaming.node.network;
public class NodeNetwork {
NioSocketConnector connector=null;
private static Logger logger = LoggerFactory.getLogger(NodeNetwork.class);
private IoSession session=null;
public IoSession getNetworkSession()
{
return this.session;
}
public boolean setupNodeNetwork()
{
connector = new NioSocketConnector();
| connector.setConnectTimeoutMillis(Config.CONNECT_TIMEOUT); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ZabbixClient.java | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
| import java.net.InetAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.quigley.zabbixj.agent.ZabbixAgent;
import com.sysu.cloudgaming.config.Config; | package com.sysu.cloudgaming.node;
public class ZabbixClient {
ZabbixAgent agent=null;
private static Logger logger = LoggerFactory.getLogger(ZabbixClient.class);
public boolean startClient()
{
try
{
ZabbixAgent agent = new ZabbixAgent();
agent.setEnableActive(true);
agent.setEnablePassive(false); | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ZabbixClient.java
import java.net.InetAddress;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.quigley.zabbixj.agent.ZabbixAgent;
import com.sysu.cloudgaming.config.Config;
package com.sysu.cloudgaming.node;
public class ZabbixClient {
ZabbixAgent agent=null;
private static Logger logger = LoggerFactory.getLogger(ZabbixClient.class);
public boolean startClient()
{
try
{
ZabbixAgent agent = new ZabbixAgent();
agent.setEnableActive(true);
agent.setEnablePassive(false); | agent.setServerAddress(InetAddress.getByName(Config.ZABBIXSERVERADDR)); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/portalnetwork/PortalNetwork.java | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
| import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config; | package com.sysu.cloudgaminghub.hub.portalnetwork;
public class PortalNetwork {
private static Logger logger = LoggerFactory.getLogger(PortalNetwork.class);
private Server server=null;
private ServletContextHandler context=null;
public boolean startPortalNetwork()
{
try
{ | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
// Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/portalnetwork/PortalNetwork.java
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config;
package com.sysu.cloudgaminghub.hub.portalnetwork;
public class PortalNetwork {
private static Logger logger = LoggerFactory.getLogger(PortalNetwork.class);
private Server server=null;
private ServletContextHandler context=null;
public boolean startPortalNetwork()
{
try
{ | server = new Server(Config.PORTALPORT); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ProgramManager.java | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
| import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config; | package com.sysu.cloudgaming.node;
public class ProgramManager {
private static Logger logger = LoggerFactory.getLogger(ProgramManager.class);
List<ProgramBean> list=new ArrayList<ProgramBean>();
public List<ProgramBean> searchLocalProgram()
{
list.clear();
try
{ | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ProgramManager.java
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config;
package com.sysu.cloudgaming.node;
public class ProgramManager {
private static Logger logger = LoggerFactory.getLogger(ProgramManager.class);
List<ProgramBean> list=new ArrayList<ProgramBean>();
public List<ProgramBean> searchLocalProgram()
{
list.clear();
try
{ | File programPath=new File(Config.LOCALPROGRAMPATH); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/nodenetwork/NodeNetwork.java | // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
| import java.net.InetSocketAddress;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config; | package com.sysu.cloudgaminghub.hub.nodenetwork;
public class NodeNetwork {
private IoAcceptor acceptor;
private static Logger logger = LoggerFactory.getLogger(NodeNetwork.class);
public boolean setupNodeNetwork()
{
acceptor = new NioSocketAcceptor();
acceptor.getSessionConfig().setReadBufferSize( 2048 );
acceptor.getSessionConfig().setIdleTime( IdleStatus.BOTH_IDLE, 10 );
acceptor.setHandler( new NodeNetworkHandler() );
acceptor.getFilterChain().addLast("protocol", new ProtocolCodecFilter(new NodeNetworkCodecFactory()));
try
{
| // Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/config/Config.java
// public class Config {
// private static Logger logger = LoggerFactory.getLogger(App.class);
// public static int HUBPORT=10060;
// public static int PORTALPORT=8090;
// public static int STUNPORT=3478;
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.03 Alpha";
// public static final String HOSTNAMEKEY="HOSTNAME";
// public static final String CONTINUATIONKEY="CONTINUATION";
// public static final String RUNRESPONSEBEAN="RUNRESPONSEBEAN";
// public static final String SUCCESSFULKEY="SUCCESS";
// public static int CONTINUATIONTIMEOUT=30000;
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
//
// }
// Path: Cloud-Deploy/sysu.cloudgaminghub/src/main/java/com/sysu/cloudgaminghub/hub/nodenetwork/NodeNetwork.java
import java.net.InetSocketAddress;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaminghub.config.Config;
package com.sysu.cloudgaminghub.hub.nodenetwork;
public class NodeNetwork {
private IoAcceptor acceptor;
private static Logger logger = LoggerFactory.getLogger(NodeNetwork.class);
public boolean setupNodeNetwork()
{
acceptor = new NioSocketAcceptor();
acceptor.getSessionConfig().setReadBufferSize( 2048 );
acceptor.getSessionConfig().setIdleTime( IdleStatus.BOTH_IDLE, 10 );
acceptor.setHandler( new NodeNetworkHandler() );
acceptor.getFilterChain().addLast("protocol", new ProtocolCodecFilter(new NodeNetworkCodecFactory()));
try
{
| acceptor.bind( new InetSocketAddress(Config.HUBPORT) ); |
elliott-wen/Remote-Gaming | Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ProgramUtils.java | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
| import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config; | package com.sysu.cloudgaming.node;
public class ProgramUtils {
private static Logger logger = LoggerFactory.getLogger(ProgramUtils.class);
public static Map<String,ProgramBean> searchLocalProgram()
{
Map<String,ProgramBean> programMap=new HashMap<String,ProgramBean>();
try
{ | // Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/config/Config.java
// public class Config {
// public static final String PROPERTYFILE="agentd.conf";
// public static String BASEPATH="d:/cloudgaming/";
// public static String VERSION="1.08 Alpha";
// public static String LOCALPROGRAMPATH="Games/";
// public static String DEAMONPATH="Server.exe";
// public static String LOCALPROGRAMXMLNAME="info.xml";
// public static String HUBSERVERADDR="222.200.182.75";
// public static int SOTIMEOUT=3000;
// public static int HUBSERVERPORT=10060;
// public static int STUNPORT=3478;
// public static int CONNECT_TIMEOUT=3000;
// public static String HOSTNAME="GameHost-X-NONAME";
// public static int REFRESHINTEVAL=10;
// private static Logger logger = LoggerFactory.getLogger(Config.class);
// public static boolean loadConfig()
// {
// logger.info("Build Version:{}",VERSION);
// try
// {
// Properties p = new Properties();
// p.load(new FileInputStream(BASEPATH+PROPERTYFILE));
// logger.info("Server address {}",p.getProperty("ServerActive"));
// HUBSERVERADDR=p.getProperty("ServerActive");
// BASEPATH=p.getProperty("BasePath");
//
// HOSTNAME=p.getProperty("Hostname");
// logger.info("HostName {}",HOSTNAME);
// if(HOSTNAME==null)
// {
// HOSTNAME=UUID.randomUUID().toString();
// p.setProperty("Hostname", HOSTNAME);
// p.store(new FileOutputStream(BASEPATH+PROPERTYFILE), "");
// logger.info("Generate A host name {}",HOSTNAME);
// }
//
// return true;
// }
// catch(Exception e)
// {
// logger.warn("Failed to read config file");
// return false;
// }
// }
// }
// Path: Cloud-Deploy/sysu.cloudgaming/src/main/java/com/sysu/cloudgaming/node/ProgramUtils.java
import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sysu.cloudgaming.config.Config;
package com.sysu.cloudgaming.node;
public class ProgramUtils {
private static Logger logger = LoggerFactory.getLogger(ProgramUtils.class);
public static Map<String,ProgramBean> searchLocalProgram()
{
Map<String,ProgramBean> programMap=new HashMap<String,ProgramBean>();
try
{ | File infoFile=new File(Config.LOCALPROGRAMPATH+"/"+Config.LOCALPROGRAMXMLNAME); |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/ScorePointLong.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple; | package redis.clients.collections.builder;
class ScorePointLong extends AbstractScoresPoint<Long> implements ScoresPoint<Long> {
ScorePointLong(Jedis jedis,String keyWithNameSpace) {
super(jedis, keyWithNameSpace);
}
@Override
public void initialPoint(String field, Long value) {
jedis.zadd(keyWithNameSpace,value.doubleValue(), field);
}
@Override
public Long increment(String field, Long value) {
return jedis.zincrby(keyWithNameSpace, value.doubleValue(), field).longValue();
}
@Override
public Long decrement(String field, Long value) {
return increment(field, -value);
}
@Override | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/main/java/redis/clients/collections/builder/ScorePointLong.java
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
package redis.clients.collections.builder;
class ScorePointLong extends AbstractScoresPoint<Long> implements ScoresPoint<Long> {
ScorePointLong(Jedis jedis,String keyWithNameSpace) {
super(jedis, keyWithNameSpace);
}
@Override
public void initialPoint(String field, Long value) {
jedis.zadd(keyWithNameSpace,value.doubleValue(), field);
}
@Override
public Long increment(String field, Long value) {
return jedis.zincrby(keyWithNameSpace, value.doubleValue(), field).longValue();
}
@Override
public Long decrement(String field, Long value) {
return increment(field, -value);
}
@Override | public List<Ranking<Long>> range(long start, long end) { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
| // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
| private keyValueRedisStructure<Person> personStructure; |
otaviojava/redis-collections | src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
| // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
| private keyValueRedisStructure<Person> personStructure; |
otaviojava/redis-collections | src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
private keyValueRedisStructure<Person> personStructure;
private keyValueRedisStructure<Person> personTemporaryStructure;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
private keyValueRedisStructure<Person> personStructure;
private keyValueRedisStructure<Person> personTemporaryStructure;
@Before
public void init() { | personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person_key_value").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
private keyValueRedisStructure<Person> personStructure;
private keyValueRedisStructure<Person> personTemporaryStructure;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/KeyValueRedsStructureTest.java
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class KeyValueRedsStructureTest {
private static final int TWO_SECONDS = 2;
private static final String UNKNOWN_PERSON_KEY = "UNKNOWN_PERSON";
private static final String OTAVIOJAVA_KEY = "otaviojava";
private static final String OTAVIOJAVA_TEMP_KEY = "otaviojava_temp";
private static final String GAMA_KEY = "gamaFominha";
private static final String FRANCESQUINI_KEY = "guardanapoRecadinho";
private keyValueRedisStructure<Person> personStructure;
private keyValueRedisStructure<Person> personTemporaryStructure;
@Before
public void init() { | personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person_key_value").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/SetStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/User.java
// public class User {
//
// private String nickName;
//
// public User(String nickName) {
// this.setNickName(nickName);
//
// }
//
// public String getNickName() {
// return nickName;
// }
//
// public void setNickName(String nickName) {
// this.nickName = nickName;
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.User;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class SetStructureTest {
private SetStructure<User> socialMediaUsers;
private User userOtavioJava = new User("otaviojava");
private User felipe = new User("ffrancesquini");
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/User.java
// public class User {
//
// private String nickName;
//
// public User(String nickName) {
// this.setNickName(nickName);
//
// }
//
// public String getNickName() {
// return nickName;
// }
//
// public void setNickName(String nickName) {
// this.nickName = nickName;
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/SetStructureTest.java
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.User;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class SetStructureTest {
private SetStructure<User> socialMediaUsers;
private User userOtavioJava = new User("otaviojava");
private User felipe = new User("ffrancesquini");
@Before
public void init() { | socialMediaUsers = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, User.class).withNameSpace("socialMedia").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/SetStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/User.java
// public class User {
//
// private String nickName;
//
// public User(String nickName) {
// this.setNickName(nickName);
//
// }
//
// public String getNickName() {
// return nickName;
// }
//
// public void setNickName(String nickName) {
// this.nickName = nickName;
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.User;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class SetStructureTest {
private SetStructure<User> socialMediaUsers;
private User userOtavioJava = new User("otaviojava");
private User felipe = new User("ffrancesquini");
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/User.java
// public class User {
//
// private String nickName;
//
// public User(String nickName) {
// this.setNickName(nickName);
//
// }
//
// public String getNickName() {
// return nickName;
// }
//
// public void setNickName(String nickName) {
// this.nickName = nickName;
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/SetStructureTest.java
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.User;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class SetStructureTest {
private SetStructure<User> socialMediaUsers;
private User userOtavioJava = new User("otaviojava");
private User felipe = new User("ffrancesquini");
@Before
public void init() { | socialMediaUsers = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, User.class).withNameSpace("socialMedia").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/MapStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Species.java
// public class Species implements Serializable {
//
// private static final long serialVersionUID = -1493508757572337719L;
//
// private List<String> animals;
//
// public Species(String... animals) {
// this.animals = Arrays.asList(animals);
// }
//
// public List<String> getAnimals() {
// return animals;
// }
// public void setAnimals(List<String> animals) {
// this.animals = animals;
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Species;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class MapStructureTest {
private MapStructure<Species> zoo;
private Species mammals = new Species("lion", "cow", "dog");
private Species fishes = new Species("redfish", "glassfish");
private Species amphibians = new Species("crododile", "frog");
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Species.java
// public class Species implements Serializable {
//
// private static final long serialVersionUID = -1493508757572337719L;
//
// private List<String> animals;
//
// public Species(String... animals) {
// this.animals = Arrays.asList(animals);
// }
//
// public List<String> getAnimals() {
// return animals;
// }
// public void setAnimals(List<String> animals) {
// this.animals = animals;
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/MapStructureTest.java
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Species;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class MapStructureTest {
private MapStructure<Species> zoo;
private Species mammals = new Species("lion", "cow", "dog");
private Species fishes = new Species("redfish", "glassfish");
private Species amphibians = new Species("crododile", "frog");
@Before
public void init() { | zoo = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Species.class).withNameSpace("animalZoo").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/MapStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Species.java
// public class Species implements Serializable {
//
// private static final long serialVersionUID = -1493508757572337719L;
//
// private List<String> animals;
//
// public Species(String... animals) {
// this.animals = Arrays.asList(animals);
// }
//
// public List<String> getAnimals() {
// return animals;
// }
// public void setAnimals(List<String> animals) {
// this.animals = animals;
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Species;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class MapStructureTest {
private MapStructure<Species> zoo;
private Species mammals = new Species("lion", "cow", "dog");
private Species fishes = new Species("redfish", "glassfish");
private Species amphibians = new Species("crododile", "frog");
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Species.java
// public class Species implements Serializable {
//
// private static final long serialVersionUID = -1493508757572337719L;
//
// private List<String> animals;
//
// public Species(String... animals) {
// this.animals = Arrays.asList(animals);
// }
//
// public List<String> getAnimals() {
// return animals;
// }
// public void setAnimals(List<String> animals) {
// this.animals = animals;
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/MapStructureTest.java
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Species;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class MapStructureTest {
private MapStructure<Species> zoo;
private Species mammals = new Species("lion", "cow", "dog");
private Species fishes = new Species("redfish", "glassfish");
private Species amphibians = new Species("crododile", "frog");
@Before
public void init() { | zoo = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Species.class).withNameSpace("animalZoo").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() {
SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/SetBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.SetStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class SetBuilderStructureTest {
@Test
public void shouldCreateListStructure() {
SetStructure<Person> personStructure = RedisStrutureBuilder.ofSet(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | CountStructure<Long> countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("countSample").withKey("countKey").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | CountStructure<Long> countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("countSample").withKey("countKey").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() { | CountStructure<Long> countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("countSample").withKey("countKey").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() {
CountStructure<Long> countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("countSample").withKey("countKey").buildLong();
Assert.assertNotNull(countStructure);
}
| // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/CountStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
@SuppressWarnings("unused")
public class CountStructureBuilderTest {
@Test
public void shouldReturnCountStrutureBuilder() {
CountStructure<Long> countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("countSample").withKey("countKey").buildLong();
Assert.assertNotNull(countStructure);
}
| @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() { | keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() {
keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build();
Assert.assertNotNull(personStructure);
}
| // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/KeyValueBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class KeyValueBuilderTest {
@Test
public void shouldCreateKeyValueStruture() {
keyValueRedisStructure<Person> personStructure = RedisStrutureBuilder.ofKeyValue(RedisConnection.JEDIS, Person.class).withNameSpace("person").withttl(120).build();
Assert.assertNotNull(personStructure);
}
| @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/SetStructureBuilder.java | // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.SetStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class SetStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
public SetStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public SetStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/SetStructure.java
// public interface SetStructure <T> {
//
// Set<T> createSet(String key);
//
// void delete(String key);
// }
// Path: src/main/java/redis/clients/collections/builder/SetStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.SetStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class SetStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
public SetStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public SetStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public SetStructure<T> build() { |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/RankingStructureLong.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
class RankingStructureLong extends AbstractExpirable<Long> implements RankingStructure<Long> {
RankingStructureLong(Jedis jedis,String nameSpace) {
super(jedis, Long.class, nameSpace);
}
@Override | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/main/java/redis/clients/collections/builder/RankingStructureLong.java
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
class RankingStructureLong extends AbstractExpirable<Long> implements RankingStructure<Long> {
RankingStructureLong(Jedis jedis,String nameSpace) {
super(jedis, Long.class, nameSpace);
}
@Override | public ScoresPoint<Long> create(String key) { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | RankingStructure<Long> structure = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("rankingSpace").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | RankingStructure<Long> structure = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("rankingSpace").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() { | RankingStructure<Long> structure = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("rankingSpace").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() {
RankingStructure<Long> structure = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("rankingSpace").buildLong();
Assert.assertNotNull(structure);
}
@SuppressWarnings("unused") | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/RankingStructureBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class RankingStructureBuilderTest {
@Test
public void shouldCreateRankingStructure() {
RankingStructure<Long> structure = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("rankingSpace").buildLong();
Assert.assertNotNull(structure);
}
@SuppressWarnings("unused") | @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/test/java/redis/clients/collections/model/ChampionShip.java | // Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import java.util.logging.Logger;
import redis.clients.collections.ScoresPoint; | package redis.clients.collections.model;
public class ChampionShip {
private static final Logger LOGGER = Logger.getLogger(ChampionShip.class.getName());
public enum ChampionShipType{
WIN(3), LOSE(0), DRAW(1);
private int point;
ChampionShipType(int point) {
this.point = point;
}
public long getPoint() {
return point;
}
}
| // Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/test/java/redis/clients/collections/model/ChampionShip.java
import java.util.logging.Logger;
import redis.clients.collections.ScoresPoint;
package redis.clients.collections.model;
public class ChampionShip {
private static final Logger LOGGER = Logger.getLogger(ChampionShip.class.getName());
public enum ChampionShipType{
WIN(3), LOSE(0), DRAW(1);
private int point;
ChampionShipType(int point) {
this.point = point;
}
public long getPoint() {
return point;
}
}
| public ChampionShipType play(TeamSoccer a, TeamSoccer b, ScoresPoint<Long> brazilianChampionShip) { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() { | QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() {
QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/QueueBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class QueueBuilderStructureTest {
@Test
public void shouldCreateListStructure() {
QueueStructure<Person> personStructure = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() { | MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() {
MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/MapBuilderStructureTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.MapStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class MapBuilderStructureTest {
@Test
public void shouldCreateMapStructure() {
MapStructure<Person> personStructure = RedisStrutureBuilder.ofMap(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
@SuppressWarnings("unused") | @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/ScorePointDouble.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple; | package redis.clients.collections.builder;
class ScorePointDouble extends AbstractScoresPoint<Double> implements ScoresPoint<Double> {
ScorePointDouble(Jedis jedis, String keyWithNameSpace) {
super(jedis, keyWithNameSpace);
}
@Override
public void initialPoint(String field, Double value) {
jedis.zadd(keyWithNameSpace, value, field);
}
@Override
public Double increment(String field, Double value) {
return jedis.zincrby(keyWithNameSpace, value, field);
}
@Override
public Double decrement(String field, Double value) {
return increment(field, -value);
}
@Override | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/main/java/redis/clients/collections/builder/ScorePointDouble.java
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
package redis.clients.collections.builder;
class ScorePointDouble extends AbstractScoresPoint<Double> implements ScoresPoint<Double> {
ScorePointDouble(Jedis jedis, String keyWithNameSpace) {
super(jedis, keyWithNameSpace);
}
@Override
public void initialPoint(String field, Double value) {
jedis.zadd(keyWithNameSpace, value, field);
}
@Override
public Double increment(String field, Double value) {
return jedis.zincrby(keyWithNameSpace, value, field);
}
@Override
public Double decrement(String field, Double value) {
return increment(field, -value);
}
@Override | public List<Ranking<Double>> range(long start, long end) { |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/RankingStructureBuilder.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.RankingStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class RankingStructureBuilder {
private String nameSpace;
private Jedis jedis;
RankingStructureBuilder() {
}
RankingStructureBuilder(Jedis jedis) {
this.jedis = jedis;
}
public RankingStructureBuilder withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
// Path: src/main/java/redis/clients/collections/builder/RankingStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.RankingStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class RankingStructureBuilder {
private String nameSpace;
private Jedis jedis;
RankingStructureBuilder() {
}
RankingStructureBuilder(Jedis jedis) {
this.jedis = jedis;
}
public RankingStructureBuilder withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public RankingStructure<Long> buildLong() { |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/ListStructureBuilder.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.ListStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class ListStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
ListStructureBuilder(Jedis jedis, Class<T> clazz) {
this.clazz = clazz;
this.jedis = jedis;
}
public ListStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
// Path: src/main/java/redis/clients/collections/builder/ListStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.ListStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class ListStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
ListStructureBuilder(Jedis jedis, Class<T> clazz) {
this.clazz = clazz;
this.jedis = jedis;
}
public ListStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public ListStructure<T> build() { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/ListBuilderTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/ListBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/ListBuilderTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/ListBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/ListBuilderTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/ListBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/ListBuilderTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/ListBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() { | ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/builder/ListBuilderTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() {
ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
| // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisBuilderException.java
// public class RedisBuilderException extends RuntimeException {
//
// private static final long serialVersionUID = 1143453384777720845L;
//
// RedisBuilderException(String message){
// super(message);
// }
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/Person.java
// public class Person implements Serializable {
//
// private static final long serialVersionUID = 5089852596376703955L;
//
// private String name;
//
// private Integer age;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public Integer getAge() {
// return age;
// }
//
// public void setAge(Integer age) {
// this.age = age;
// }
//
// public Person(String name, Integer age) {
// this.name = name;
// this.age = age;
// }
//
// public Person() {
//
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/builder/ListBuilderTest.java
import junit.framework.Assert;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisBuilderException;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.Person;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections.builder;
public class ListBuilderTest {
@Test
public void shouldCreateListStructure() {
ListStructure<Person> personStructure = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, Person.class).withNameSpace("nameSpaceList").build();
Assert.assertNotNull(personStructure);
}
| @Test(expected = RedisBuilderException.class) |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/MapStructureBuilder.java | // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.MapStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class MapStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
MapStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public MapStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/MapStructure.java
// public interface MapStructure <T> extends Expirable{
//
//
// Map<String, T> get(String key);
//
// void delete(String key);
//
// }
// Path: src/main/java/redis/clients/collections/builder/MapStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.MapStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class MapStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
MapStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public MapStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public MapStructure<T> build() { |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/KeyValueBuilder.java | // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class KeyValueBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private int ttl;
private Jedis jedis;
KeyValueBuilder(Jedis jedis, Class<T> clazz) {
this.clazz = clazz;
this.jedis = jedis;
}
public KeyValueBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
public KeyValueBuilder<T> withttl(int ttl) {
this.ttl = ttl;
return this;
}
| // Path: src/main/java/redis/clients/collections/keyValueRedisStructure.java
// public interface keyValueRedisStructure<T> {
//
// T get(String key);
//
// void set(String key, T bean);
//
// List<T> multiplesGet(Iterable<String> keys);
//
// void delete(String key);
// }
// Path: src/main/java/redis/clients/collections/builder/KeyValueBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.keyValueRedisStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class KeyValueBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private int ttl;
private Jedis jedis;
KeyValueBuilder(Jedis jedis, Class<T> clazz) {
this.clazz = clazz;
this.jedis = jedis;
}
public KeyValueBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
public KeyValueBuilder<T> withttl(int ttl) {
this.ttl = ttl;
return this;
}
| public keyValueRedisStructure<T> build() { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/CountStructureTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class CountStructureTest {
private CountStructure<Long> countStructure;
private CountStructure<Double> countFluctuateStructure;
@Before
public void init() {
| // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/CountStructureTest.java
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class CountStructureTest {
private CountStructure<Long> countStructure;
private CountStructure<Double> countFluctuateStructure;
@Before
public void init() {
| countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("count_pages").withKey("products").buildLong(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/CountStructureTest.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class CountStructureTest {
private CountStructure<Long> countStructure;
private CountStructure<Double> countFluctuateStructure;
@Before
public void init() {
| // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/CountStructureTest.java
import junit.framework.Assert;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.CountStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class CountStructureTest {
private CountStructure<Long> countStructure;
private CountStructure<Double> countFluctuateStructure;
@Before
public void init() {
| countStructure = RedisStrutureBuilder.ofCount(RedisConnection.JEDIS).withNameSpace("count_pages").withKey("products").buildLong(); |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/RankingStructureDouble.java | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
class RankingStructureDouble extends AbstractExpirable<Double> implements RankingStructure<Double> {
RankingStructureDouble(Jedis jedis, String nameSpace) {
super(jedis, Double.class, nameSpace);
}
@Override | // Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/main/java/redis/clients/collections/builder/RankingStructureDouble.java
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
class RankingStructureDouble extends AbstractExpirable<Double> implements RankingStructure<Double> {
RankingStructureDouble(Jedis jedis, String nameSpace) {
super(jedis, Double.class, nameSpace);
}
@Override | public ScoresPoint<Double> create(String key) { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/RankingStructureDoubleTest.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/RankingStructureDoubleTest.java
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() { | laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/RankingStructureDoubleTest.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/RankingStructureDoubleTest.java
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() { | laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/RankingStructureDoubleTest.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() {
laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble();
}
@Test
public void shouldAddAndRemoveValue() { | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/RankingStructureDoubleTest.java
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() {
laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble();
}
@Test
public void shouldAddAndRemoveValue() { | ScoresPoint<Double> sneeze = laughThings.create("sneeze"); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/RankingStructureDoubleTest.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() {
laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble();
}
@Test
public void shouldAddAndRemoveValue() {
ScoresPoint<Double> sneeze = laughThings.create("sneeze");
sneeze.increment("Newton", 24.2424242424);
sneeze.increment("Erish", 25.9);
sneeze.increment("David", 924.786);
| // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/RankingStructure.java
// public interface RankingStructure<T extends Number> extends Expirable {
//
// ScoresPoint<T> create(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/RankingStructureDoubleTest.java
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.Ranking;
import redis.clients.collections.RankingStructure;
import redis.clients.collections.ScoresPoint;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class RankingStructureDoubleTest {
private RankingStructure<Double> laughThings;
@Before
public void init() {
laughThings = RedisStrutureBuilder.ofRanking(RedisConnection.JEDIS).withNameSpace("laughThings").buildDouble();
}
@Test
public void shouldAddAndRemoveValue() {
ScoresPoint<Double> sneeze = laughThings.create("sneeze");
sneeze.increment("Newton", 24.2424242424);
sneeze.increment("Erish", 25.9);
sneeze.increment("David", 924.786);
| List<Ranking<Double>> ranking = sneeze.getRanking(); |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/AbstractScoresPoint.java | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
| import java.util.List;
import java.util.Objects;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
abstract class AbstractScoresPoint<T extends Number> implements ScoresPoint<T> {
protected String keyWithNameSpace;
protected Jedis jedis;
AbstractScoresPoint(Jedis jedis, String keyWithNameSpace) {
this.keyWithNameSpace = keyWithNameSpace;
this.jedis = jedis;
}
@Override
public void remove(String name) {
jedis.zrem(keyWithNameSpace, name);
}
@Override
public int size() {
return jedis.zcard(keyWithNameSpace).intValue();
}
@Override | // Path: src/main/java/redis/clients/collections/Ranking.java
// public interface Ranking<T extends Number> {
//
// T getPoints();
//
// String getName();
// }
//
// Path: src/main/java/redis/clients/collections/ScoresPoint.java
// public interface ScoresPoint<T extends Number> {
//
// void initialPoint(String name, T value);
//
// T increment(String field, T value);
//
// T decrement(String field, T value);
//
// void remove(String field);
//
// int size();
//
// List<Ranking<T>> range(long initial, long end);
//
// List<Ranking<T>> top(int top);
//
// List<Ranking<T>> last(int top);
//
// List<Ranking<T>> getRanking();
// }
// Path: src/main/java/redis/clients/collections/builder/AbstractScoresPoint.java
import java.util.List;
import java.util.Objects;
import redis.clients.collections.Ranking;
import redis.clients.collections.ScoresPoint;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
abstract class AbstractScoresPoint<T extends Number> implements ScoresPoint<T> {
protected String keyWithNameSpace;
protected Jedis jedis;
AbstractScoresPoint(Jedis jedis, String keyWithNameSpace) {
this.keyWithNameSpace = keyWithNameSpace;
this.jedis = jedis;
}
@Override
public void remove(String name) {
jedis.zrem(keyWithNameSpace, name);
}
@Override
public int size() {
return jedis.zcard(keyWithNameSpace).intValue();
}
@Override | public List<Ranking<T>> top(int top) { |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/QueueStructureBuilder.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.QueueStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class QueueStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
QueueStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public QueueStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
// Path: src/main/java/redis/clients/collections/builder/QueueStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.QueueStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class QueueStructureBuilder<T> {
private Class<T> clazz;
private String nameSpace;
private Jedis jedis;
QueueStructureBuilder(Jedis jedis, Class<T> clazz) {
this.jedis = jedis;
this.clazz = clazz;
}
public QueueStructureBuilder<T> withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public QueueStructure<T> build() { |
otaviojava/redis-collections | src/test/java/redis/clients/collections/ListStructureTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits"; | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/ListStructureTest.java
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits"; | private ProductCart banana = new ProductCart("banana", BigDecimal.ONE); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/ListStructureTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
| // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/ListStructureTest.java
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
| private ListStructure<ProductCart> shippingCart; |
otaviojava/redis-collections | src/test/java/redis/clients/collections/ListStructureTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
private ListStructure<ProductCart> shippingCart;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/ListStructureTest.java
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
private ListStructure<ProductCart> shippingCart;
@Before
public void init() { | shippingCart = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, ProductCart.class).withNameSpace("list_producs").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/ListStructureTest.java | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
private ListStructure<ProductCart> shippingCart;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/ListStructure.java
// public interface ListStructure <T> extends Expirable {
//
// List<T> get(String key);
//
// void delete(String key);
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/ProductCart.java
// public class ProductCart implements Serializable {
//
// private static final long serialVersionUID = 4087960613230439836L;
//
// private String name;
//
// private BigDecimal price;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public BigDecimal getPrice() {
// return price;
// }
//
// public void setPrice(BigDecimal price) {
// this.price = price;
// }
//
// public ProductCart(String name, BigDecimal price) {
// this.name = name;
// this.price = price;
// }
//
// public ProductCart() {}
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/ListStructureTest.java
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.ListStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.ProductCart;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class ListStructureTest {
private static final String FRUITS = "fruits";
private ProductCart banana = new ProductCart("banana", BigDecimal.ONE);
private ProductCart orange = new ProductCart("orange", BigDecimal.ONE);
private ProductCart waterMelon = new ProductCart("waterMelon", BigDecimal.TEN);
private ProductCart melon = new ProductCart("melon", BigDecimal.ONE);
private ListStructure<ProductCart> shippingCart;
@Before
public void init() { | shippingCart = RedisStrutureBuilder.ofList(RedisConnection.JEDIS, ProductCart.class).withNameSpace("list_producs").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/QueueStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/LineBank.java
// public class LineBank {
//
//
// private Person person;
//
// public Person getPerson() {
// return person;
// }
//
// public void setPerson(Person person) {
// this.person = person;
// }
//
// public LineBank(String name, Integer age) {
// this.person = new Person(name, age);
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.NoSuchElementException;
import java.util.Queue;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.LineBank;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class QueueStructureTest {
private QueueStructure<LineBank> serviceBank;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/LineBank.java
// public class LineBank {
//
//
// private Person person;
//
// public Person getPerson() {
// return person;
// }
//
// public void setPerson(Person person) {
// this.person = person;
// }
//
// public LineBank(String name, Integer age) {
// this.person = new Person(name, age);
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/QueueStructureTest.java
import java.util.NoSuchElementException;
import java.util.Queue;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.LineBank;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class QueueStructureTest {
private QueueStructure<LineBank> serviceBank;
@Before
public void init() { | serviceBank = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, LineBank.class).withNameSpace("serviceBank").build(); |
otaviojava/redis-collections | src/test/java/redis/clients/collections/QueueStructureTest.java | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/LineBank.java
// public class LineBank {
//
//
// private Person person;
//
// public Person getPerson() {
// return person;
// }
//
// public void setPerson(Person person) {
// this.person = person;
// }
//
// public LineBank(String name, Integer age) {
// this.person = new Person(name, age);
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
| import java.util.NoSuchElementException;
import java.util.Queue;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.LineBank;
import redis.clients.collections.util.RedisConnection; | package redis.clients.collections;
public class QueueStructureTest {
private QueueStructure<LineBank> serviceBank;
@Before
public void init() { | // Path: src/main/java/redis/clients/collections/QueueStructure.java
// public interface QueueStructure <T> extends Expirable {
//
//
// Queue<T> get(String key);
//
// void delete(String key);
//
// }
//
// Path: src/main/java/redis/clients/collections/builder/RedisStrutureBuilder.java
// public class RedisStrutureBuilder {
//
// public static <T> KeyValueBuilder<T> ofKeyValue(Jedis jedis,Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the RedisStruturebuilder");
// return new KeyValueBuilder<>(jedis, clazz);
// }
//
// public static CountStructureBuilder ofCount(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new CountStructureBuilder(jedis);
// }
//
// public static <T> ListStructureBuilder<T> ofList(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the ListStruturebuilder");
// return new ListStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> SetStructureBuilder<T> ofSet(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the SetStruturebuilder");
// return new SetStructureBuilder<>(jedis, clazz);
// }
//
// public static <T> MapStructureBuilder<T> ofMap(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz, "The class must be specificed to do the MapStruturebuilder");
// return new MapStructureBuilder<>(jedis, clazz);
//
// }
//
// public static <T> QueueStructureBuilder<T> ofQueue(Jedis jedis, Class<T> clazz) {
// Objects.requireNonNull(jedis);
// Objects.requireNonNull(clazz);
// return new QueueStructureBuilder<>(jedis, clazz);
// }
//
// public static RankingStructureBuilder ofRanking(Jedis jedis) {
// Objects.requireNonNull(jedis);
// return new RankingStructureBuilder(jedis);
// }
//
// }
//
// Path: src/test/java/redis/clients/collections/model/LineBank.java
// public class LineBank {
//
//
// private Person person;
//
// public Person getPerson() {
// return person;
// }
//
// public void setPerson(Person person) {
// this.person = person;
// }
//
// public LineBank(String name, Integer age) {
// this.person = new Person(name, age);
// }
//
//
// }
//
// Path: src/test/java/redis/clients/collections/util/RedisConnection.java
// public class RedisConnection {
//
// public static final Jedis JEDIS;
//
// static{
// JEDIS = new Jedis("localhost");
// }
// }
// Path: src/test/java/redis/clients/collections/QueueStructureTest.java
import java.util.NoSuchElementException;
import java.util.Queue;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.collections.QueueStructure;
import redis.clients.collections.builder.RedisStrutureBuilder;
import redis.clients.collections.model.LineBank;
import redis.clients.collections.util.RedisConnection;
package redis.clients.collections;
public class QueueStructureTest {
private QueueStructure<LineBank> serviceBank;
@Before
public void init() { | serviceBank = RedisStrutureBuilder.ofQueue(RedisConnection.JEDIS, LineBank.class).withNameSpace("serviceBank").build(); |
otaviojava/redis-collections | src/main/java/redis/clients/collections/builder/CountStructureBuilder.java | // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
| import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.CountStructure;
import redis.clients.jedis.Jedis; | package redis.clients.collections.builder;
public class CountStructureBuilder {
private String nameSpace;
private String key;
private Jedis jedis;
CountStructureBuilder(Jedis jedis) {
this.jedis = jedis;
}
public CountStructureBuilder withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| // Path: src/main/java/redis/clients/collections/CountStructure.java
// public interface CountStructure<T extends Number> {
//
// T get();
//
// T increment();
//
// T increment(T count);
//
// T decrement();
//
// T decrement(T count);
//
// void delete();
//
// void expires(int ttlSeconds);
//
// void persist();
// }
// Path: src/main/java/redis/clients/collections/builder/CountStructureBuilder.java
import org.apache.commons.lang3.StringUtils;
import redis.clients.collections.CountStructure;
import redis.clients.jedis.Jedis;
package redis.clients.collections.builder;
public class CountStructureBuilder {
private String nameSpace;
private String key;
private Jedis jedis;
CountStructureBuilder(Jedis jedis) {
this.jedis = jedis;
}
public CountStructureBuilder withNameSpace(String nameSpace) {
this.nameSpace = nameSpace;
return this;
}
| public CountStructure<Long> buildLong() { |
metaborg/java-front | jar-analyzer/src/main/java/mb/jar_analyzer/stxlib/StxLibCommand.java | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/JarUtils.java
// public class JarUtils {
//
// public static final void processJarClasses(Iterable<File> files, ClassProcessor processor) throws IOException {
// for(File file : files) {
// try(JarFile jar = new JarFile(file)) {
// final Enumeration<JarEntry> entries = jar.entries();
// while(entries.hasMoreElements()) {
// final JarEntry entry = entries.nextElement();
// if(entry.getName().endsWith(".class")) {
// final ClassReader classReader = new ClassReader(jar.getInputStream(entry));
// processor.accept(classReader);
// }
// }
// }
// }
// }
//
// public static final Map<String, ClassNode> readJarClasses(Iterable<File> files) throws IOException {
// final Map<String, ClassNode> classes = new HashMap<>();
// processJarClasses(files, cr -> {
// final ClassNode classNode = new ClassNode();
// cr.accept(classNode, ClassReader.SKIP_CODE & ClassReader.SKIP_DEBUG & ClassReader.SKIP_FRAMES);
// if(classes.put(classNode.name, classNode) != null) {
// throw new IllegalArgumentException("Duplicate class " + classNode.name);
// }
// });
// return classes;
// }
//
// public static boolean isJavaClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// // || name.startsWith("javax/")
// ;
// // @formatter:on
// }
//
// public static boolean isJDKClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// || name.startsWith("javax/")
// || name.startsWith("sun/")
// || name.startsWith("jdk/")
// || name.startsWith("com/sun/")
// || name.startsWith("com/apple/")
// || name.startsWith("com/oracle/")
// || name.startsWith("org/w3c/")
// || name.startsWith("org/xml/")
// || name.startsWith("org/omg/")
// || name.startsWith("org/ietf/")
// || name.startsWith("org/jcp/")
// || name.startsWith("apple/")
// ;
// // @formatter:on
// }
//
// }
| import static mb.nabl2.terms.build.TermBuild.B;
import java.io.File;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.metaborg.util.Ref;
import org.metaborg.util.functions.Action2;
import org.metaborg.util.functions.Predicate1;
import org.metaborg.util.tuple.Tuple2;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureReader;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.InnerClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.spoofax.interpreter.terms.IStrategoTerm;
import org.spoofax.terms.TermFactory;
import org.spoofax.terms.io.SimpleTextTermWriter;
import org.spoofax.terms.io.TermWriter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import com.google.common.collect.Streams;
import mb.jar_analyzer.jar.JarUtils;
import mb.nabl2.terms.ITerm;
import mb.nabl2.terms.stratego.StrategoTerms;
import mb.scopegraph.oopsla20.IScopeGraph;
import mb.scopegraph.oopsla20.reference.ScopeGraph;
import mb.statix.concurrent.IStatixLibrary;
import mb.statix.concurrent.StatixLibrary;
import mb.statix.scopegraph.Scope; | private static final String VARARGS = "VARARGS";
private static final String INIT = "<init>";
// @formatter:off
private static final Map<String, ITerm> boxedTypes = ImmutableMap.<String, ITerm>builder()
.put("java/lang/Boolean", B.newAppl("BOOLEAN"))
.put("java/lang/Character", B.newAppl("CHAR"))
.put("java/lang/Byte", B.newAppl("BYTE"))
.put("java/lang/Short", B.newAppl("SHORT"))
.put("java/lang/Integer", B.newAppl("INT"))
.put("java/lang/Long", B.newAppl("LONG"))
.put("java/lang/Float", B.newAppl("FLOAT"))
.put("java/lang/Double", B.newAppl("DOUBLE"))
.build();
// @formatter:on
// @formatter:off
private static final Set<String> jreTypes = ImmutableSet.<String>builder()
.add("java/lang/String")
.add("java/lang/Throwable")
.add("java/lang/Enum")
.add("java/lang/Iterable")
.build();
// @formatter:on
////////////////////////////////////////////////////////////////////////////
private final List<File> files = new ArrayList<>();
private File output = null; | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/JarUtils.java
// public class JarUtils {
//
// public static final void processJarClasses(Iterable<File> files, ClassProcessor processor) throws IOException {
// for(File file : files) {
// try(JarFile jar = new JarFile(file)) {
// final Enumeration<JarEntry> entries = jar.entries();
// while(entries.hasMoreElements()) {
// final JarEntry entry = entries.nextElement();
// if(entry.getName().endsWith(".class")) {
// final ClassReader classReader = new ClassReader(jar.getInputStream(entry));
// processor.accept(classReader);
// }
// }
// }
// }
// }
//
// public static final Map<String, ClassNode> readJarClasses(Iterable<File> files) throws IOException {
// final Map<String, ClassNode> classes = new HashMap<>();
// processJarClasses(files, cr -> {
// final ClassNode classNode = new ClassNode();
// cr.accept(classNode, ClassReader.SKIP_CODE & ClassReader.SKIP_DEBUG & ClassReader.SKIP_FRAMES);
// if(classes.put(classNode.name, classNode) != null) {
// throw new IllegalArgumentException("Duplicate class " + classNode.name);
// }
// });
// return classes;
// }
//
// public static boolean isJavaClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// // || name.startsWith("javax/")
// ;
// // @formatter:on
// }
//
// public static boolean isJDKClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// || name.startsWith("javax/")
// || name.startsWith("sun/")
// || name.startsWith("jdk/")
// || name.startsWith("com/sun/")
// || name.startsWith("com/apple/")
// || name.startsWith("com/oracle/")
// || name.startsWith("org/w3c/")
// || name.startsWith("org/xml/")
// || name.startsWith("org/omg/")
// || name.startsWith("org/ietf/")
// || name.startsWith("org/jcp/")
// || name.startsWith("apple/")
// ;
// // @formatter:on
// }
//
// }
// Path: jar-analyzer/src/main/java/mb/jar_analyzer/stxlib/StxLibCommand.java
import static mb.nabl2.terms.build.TermBuild.B;
import java.io.File;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.metaborg.util.Ref;
import org.metaborg.util.functions.Action2;
import org.metaborg.util.functions.Predicate1;
import org.metaborg.util.tuple.Tuple2;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureReader;
import org.objectweb.asm.signature.SignatureVisitor;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.InnerClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.spoofax.interpreter.terms.IStrategoTerm;
import org.spoofax.terms.TermFactory;
import org.spoofax.terms.io.SimpleTextTermWriter;
import org.spoofax.terms.io.TermWriter;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import com.google.common.collect.Streams;
import mb.jar_analyzer.jar.JarUtils;
import mb.nabl2.terms.ITerm;
import mb.nabl2.terms.stratego.StrategoTerms;
import mb.scopegraph.oopsla20.IScopeGraph;
import mb.scopegraph.oopsla20.reference.ScopeGraph;
import mb.statix.concurrent.IStatixLibrary;
import mb.statix.concurrent.StatixLibrary;
import mb.statix.scopegraph.Scope;
private static final String VARARGS = "VARARGS";
private static final String INIT = "<init>";
// @formatter:off
private static final Map<String, ITerm> boxedTypes = ImmutableMap.<String, ITerm>builder()
.put("java/lang/Boolean", B.newAppl("BOOLEAN"))
.put("java/lang/Character", B.newAppl("CHAR"))
.put("java/lang/Byte", B.newAppl("BYTE"))
.put("java/lang/Short", B.newAppl("SHORT"))
.put("java/lang/Integer", B.newAppl("INT"))
.put("java/lang/Long", B.newAppl("LONG"))
.put("java/lang/Float", B.newAppl("FLOAT"))
.put("java/lang/Double", B.newAppl("DOUBLE"))
.build();
// @formatter:on
// @formatter:off
private static final Set<String> jreTypes = ImmutableSet.<String>builder()
.add("java/lang/String")
.add("java/lang/Throwable")
.add("java/lang/Enum")
.add("java/lang/Iterable")
.build();
// @formatter:on
////////////////////////////////////////////////////////////////////////////
private final List<File> files = new ArrayList<>();
private File output = null; | private Predicate1<String> include = className -> JarUtils.isJavaClass(className); |
metaborg/java-front | jar-analyzer/src/main/java/mb/jar_analyzer/deps/DepsCommand.java | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/JarUtils.java
// public class JarUtils {
//
// public static final void processJarClasses(Iterable<File> files, ClassProcessor processor) throws IOException {
// for(File file : files) {
// try(JarFile jar = new JarFile(file)) {
// final Enumeration<JarEntry> entries = jar.entries();
// while(entries.hasMoreElements()) {
// final JarEntry entry = entries.nextElement();
// if(entry.getName().endsWith(".class")) {
// final ClassReader classReader = new ClassReader(jar.getInputStream(entry));
// processor.accept(classReader);
// }
// }
// }
// }
// }
//
// public static final Map<String, ClassNode> readJarClasses(Iterable<File> files) throws IOException {
// final Map<String, ClassNode> classes = new HashMap<>();
// processJarClasses(files, cr -> {
// final ClassNode classNode = new ClassNode();
// cr.accept(classNode, ClassReader.SKIP_CODE & ClassReader.SKIP_DEBUG & ClassReader.SKIP_FRAMES);
// if(classes.put(classNode.name, classNode) != null) {
// throw new IllegalArgumentException("Duplicate class " + classNode.name);
// }
// });
// return classes;
// }
//
// public static boolean isJavaClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// // || name.startsWith("javax/")
// ;
// // @formatter:on
// }
//
// public static boolean isJDKClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// || name.startsWith("javax/")
// || name.startsWith("sun/")
// || name.startsWith("jdk/")
// || name.startsWith("com/sun/")
// || name.startsWith("com/apple/")
// || name.startsWith("com/oracle/")
// || name.startsWith("org/w3c/")
// || name.startsWith("org/xml/")
// || name.startsWith("org/omg/")
// || name.startsWith("org/ietf/")
// || name.startsWith("org/jcp/")
// || name.startsWith("apple/")
// ;
// // @formatter:on
// }
//
// }
| import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Streams;
import mb.jar_analyzer.jar.JarUtils;
import mb.nabl2.util.TopoSorter;
import mb.nabl2.util.TopoSorter.TopoSortedComponents; | package mb.jar_analyzer.deps;
public class DepsCommand implements Runnable {
private final List<File> files = new ArrayList<>();
public DepsCommand(List<String> args) {
Iterator<String> it = args.iterator();
while(it.hasNext()) {
String arg = it.next();
switch(arg) {
default:
files.add(new File(arg));
case "--":
Streams.stream(it).forEach(f -> files.add(new File(f)));
break;
}
}
}
@Override public void run() { | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/JarUtils.java
// public class JarUtils {
//
// public static final void processJarClasses(Iterable<File> files, ClassProcessor processor) throws IOException {
// for(File file : files) {
// try(JarFile jar = new JarFile(file)) {
// final Enumeration<JarEntry> entries = jar.entries();
// while(entries.hasMoreElements()) {
// final JarEntry entry = entries.nextElement();
// if(entry.getName().endsWith(".class")) {
// final ClassReader classReader = new ClassReader(jar.getInputStream(entry));
// processor.accept(classReader);
// }
// }
// }
// }
// }
//
// public static final Map<String, ClassNode> readJarClasses(Iterable<File> files) throws IOException {
// final Map<String, ClassNode> classes = new HashMap<>();
// processJarClasses(files, cr -> {
// final ClassNode classNode = new ClassNode();
// cr.accept(classNode, ClassReader.SKIP_CODE & ClassReader.SKIP_DEBUG & ClassReader.SKIP_FRAMES);
// if(classes.put(classNode.name, classNode) != null) {
// throw new IllegalArgumentException("Duplicate class " + classNode.name);
// }
// });
// return classes;
// }
//
// public static boolean isJavaClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// // || name.startsWith("javax/")
// ;
// // @formatter:on
// }
//
// public static boolean isJDKClass(String name) {
// // @formatter:off
// return name.startsWith("java/")
// || name.startsWith("javax/")
// || name.startsWith("sun/")
// || name.startsWith("jdk/")
// || name.startsWith("com/sun/")
// || name.startsWith("com/apple/")
// || name.startsWith("com/oracle/")
// || name.startsWith("org/w3c/")
// || name.startsWith("org/xml/")
// || name.startsWith("org/omg/")
// || name.startsWith("org/ietf/")
// || name.startsWith("org/jcp/")
// || name.startsWith("apple/")
// ;
// // @formatter:on
// }
//
// }
// Path: jar-analyzer/src/main/java/mb/jar_analyzer/deps/DepsCommand.java
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Streams;
import mb.jar_analyzer.jar.JarUtils;
import mb.nabl2.util.TopoSorter;
import mb.nabl2.util.TopoSorter.TopoSortedComponents;
package mb.jar_analyzer.deps;
public class DepsCommand implements Runnable {
private final List<File> files = new ArrayList<>();
public DepsCommand(List<String> args) {
Iterator<String> it = args.iterator();
while(it.hasNext()) {
String arg = it.next();
switch(arg) {
default:
files.add(new File(arg));
case "--":
Streams.stream(it).forEach(f -> files.add(new File(f)));
break;
}
}
}
@Override public void run() { | final DependencyCollector depsCollector = new DependencyCollector(n -> !JarUtils.isJDKClass(n), false); |
metaborg/java-front | jar-analyzer/src/main/java/mb/jar_analyzer/deps/DependencyCollector.java | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/TypeUtil.java
// public final class TypeUtil {
//
// public static Optional<String> getTypeName(Type type) {
// switch(type.getSort()) {
// case Type.ARRAY:
// return getTypeName(type.getElementType());
// case Type.OBJECT:
// return Optional.of(type.getInternalName());
// default:
// return Optional.empty();
// }
// }
//
// }
//
// Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/ClassProcessor.java
// @FunctionalInterface
// public interface ClassProcessor {
//
// void accept(ClassReader classReader);
//
// }
| import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Handle;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import mb.jar_analyzer.TypeUtil;
import mb.jar_analyzer.jar.ClassProcessor; | }
@Override public void visitInvokeDynamicInsn(String name, String desc, Handle bootstrapMethodHandle,
Object... bootstrapMethodArguments) {
Type type = Type.getMethodType(desc);
addDependency(type.getReturnType().getInternalName());
for(Type param : type.getArgumentTypes()) {
addDependency(param.getInternalName());
}
}
@Override public void visitLdcInsn(Object value) {
if(value instanceof Type) {
addDependency(((Type) value).getInternalName());
}
}
};
}
@Override public void visitEnd() {
currentName = null;
}
private void addDependency(String typeOrName) {
if(typeOrName == null) {
return;
}
String name = null;
try { | // Path: jar-analyzer/src/main/java/mb/jar_analyzer/TypeUtil.java
// public final class TypeUtil {
//
// public static Optional<String> getTypeName(Type type) {
// switch(type.getSort()) {
// case Type.ARRAY:
// return getTypeName(type.getElementType());
// case Type.OBJECT:
// return Optional.of(type.getInternalName());
// default:
// return Optional.empty();
// }
// }
//
// }
//
// Path: jar-analyzer/src/main/java/mb/jar_analyzer/jar/ClassProcessor.java
// @FunctionalInterface
// public interface ClassProcessor {
//
// void accept(ClassReader classReader);
//
// }
// Path: jar-analyzer/src/main/java/mb/jar_analyzer/deps/DependencyCollector.java
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Handle;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import mb.jar_analyzer.TypeUtil;
import mb.jar_analyzer.jar.ClassProcessor;
}
@Override public void visitInvokeDynamicInsn(String name, String desc, Handle bootstrapMethodHandle,
Object... bootstrapMethodArguments) {
Type type = Type.getMethodType(desc);
addDependency(type.getReturnType().getInternalName());
for(Type param : type.getArgumentTypes()) {
addDependency(param.getInternalName());
}
}
@Override public void visitLdcInsn(Object value) {
if(value instanceof Type) {
addDependency(((Type) value).getInternalName());
}
}
};
}
@Override public void visitEnd() {
currentName = null;
}
private void addDependency(String typeOrName) {
if(typeOrName == null) {
return;
}
String name = null;
try { | name = TypeUtil.getTypeName(Type.getType(typeOrName)).orElse(null); |
mlk/AssortmentOfJUnitRules | src/test/java/com/github/mlk/junit/rules/helpers/dynamodb/DynamoDBClientWithStubbedWaiterTest.java | // Path: src/main/java/com/github/mlk/junit/dynamo/DynamoDBClientWithStubbedWaiter.java
// @AllArgsConstructor
// public class DynamoDBClientWithStubbedWaiter implements AmazonDynamoDB {
// @Delegate(types = AmazonDynamoDB.class, excludes = Exclude.class)
// private AmazonDynamoDB wrapped;
//
// @Override
// public AmazonDynamoDBWaiters waiters() {
// return new AmazonDynamoDBWaiters(wrapped);
// }
//
// interface Exclude {
// AmazonDynamoDBWaiters waiters();
// }
// }
//
// Path: src/main/java/com/github/mlk/junit/rules/LocalDynamoDbRule.java
// public class LocalDynamoDbRule extends ExternalResource implements DynamoDbRule {
//
// private AmazonDynamoDB client;
// private final NativeLibraryRule nativeLibraryRule;
//
// public LocalDynamoDbRule() {
// nativeLibraryRule = new NativeLibraryRule(Pattern.compile(".*sqlite.*"));
// }
//
// /** This returns the client returned by the local Amazon DynamoDB server.
// * You may wish to wrap this with the DynamoDBClientWithStubbedWaiter.
// *
// * @see DynamoDBClientWithStubbedWaiter
// * @return A Amazon DynamoDB client.
// */
// public AmazonDynamoDB getClient() {
// return client;
// }
//
// @Override
// protected void before() throws Throwable {
// nativeLibraryRule.before();
// System.setProperty("sqlite4java.library.path", nativeLibraryRule.getNativeLibrariesFolder().toString());
//
// client = DynamoDBEmbedded.create().amazonDynamoDB();
// }
//
// @Override
// protected void after() {
// try {
// client.shutdown();
// } catch (Exception e) {
// e.printStackTrace();
// }
// nativeLibraryRule.after();
// }
// }
| import static java.util.Collections.singleton;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
import com.github.mlk.junit.dynamo.DynamoDBClientWithStubbedWaiter;
import com.github.mlk.junit.rules.LocalDynamoDbRule;
import java.util.ArrayList;
import java.util.List;
import org.junit.Rule;
import org.junit.Test; | package com.github.mlk.junit.rules.helpers.dynamodb;
public class DynamoDBClientWithStubbedWaiterTest {
@Rule | // Path: src/main/java/com/github/mlk/junit/dynamo/DynamoDBClientWithStubbedWaiter.java
// @AllArgsConstructor
// public class DynamoDBClientWithStubbedWaiter implements AmazonDynamoDB {
// @Delegate(types = AmazonDynamoDB.class, excludes = Exclude.class)
// private AmazonDynamoDB wrapped;
//
// @Override
// public AmazonDynamoDBWaiters waiters() {
// return new AmazonDynamoDBWaiters(wrapped);
// }
//
// interface Exclude {
// AmazonDynamoDBWaiters waiters();
// }
// }
//
// Path: src/main/java/com/github/mlk/junit/rules/LocalDynamoDbRule.java
// public class LocalDynamoDbRule extends ExternalResource implements DynamoDbRule {
//
// private AmazonDynamoDB client;
// private final NativeLibraryRule nativeLibraryRule;
//
// public LocalDynamoDbRule() {
// nativeLibraryRule = new NativeLibraryRule(Pattern.compile(".*sqlite.*"));
// }
//
// /** This returns the client returned by the local Amazon DynamoDB server.
// * You may wish to wrap this with the DynamoDBClientWithStubbedWaiter.
// *
// * @see DynamoDBClientWithStubbedWaiter
// * @return A Amazon DynamoDB client.
// */
// public AmazonDynamoDB getClient() {
// return client;
// }
//
// @Override
// protected void before() throws Throwable {
// nativeLibraryRule.before();
// System.setProperty("sqlite4java.library.path", nativeLibraryRule.getNativeLibrariesFolder().toString());
//
// client = DynamoDBEmbedded.create().amazonDynamoDB();
// }
//
// @Override
// protected void after() {
// try {
// client.shutdown();
// } catch (Exception e) {
// e.printStackTrace();
// }
// nativeLibraryRule.after();
// }
// }
// Path: src/test/java/com/github/mlk/junit/rules/helpers/dynamodb/DynamoDBClientWithStubbedWaiterTest.java
import static java.util.Collections.singleton;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
import com.github.mlk.junit.dynamo.DynamoDBClientWithStubbedWaiter;
import com.github.mlk.junit.rules.LocalDynamoDbRule;
import java.util.ArrayList;
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
package com.github.mlk.junit.rules.helpers.dynamodb;
public class DynamoDBClientWithStubbedWaiterTest {
@Rule | public LocalDynamoDbRule dynamoDbRule = new LocalDynamoDbRule(); |
mlk/AssortmentOfJUnitRules | src/test/java/com/github/mlk/junit/rules/helpers/dynamodb/DynamoDBClientWithStubbedWaiterTest.java | // Path: src/main/java/com/github/mlk/junit/dynamo/DynamoDBClientWithStubbedWaiter.java
// @AllArgsConstructor
// public class DynamoDBClientWithStubbedWaiter implements AmazonDynamoDB {
// @Delegate(types = AmazonDynamoDB.class, excludes = Exclude.class)
// private AmazonDynamoDB wrapped;
//
// @Override
// public AmazonDynamoDBWaiters waiters() {
// return new AmazonDynamoDBWaiters(wrapped);
// }
//
// interface Exclude {
// AmazonDynamoDBWaiters waiters();
// }
// }
//
// Path: src/main/java/com/github/mlk/junit/rules/LocalDynamoDbRule.java
// public class LocalDynamoDbRule extends ExternalResource implements DynamoDbRule {
//
// private AmazonDynamoDB client;
// private final NativeLibraryRule nativeLibraryRule;
//
// public LocalDynamoDbRule() {
// nativeLibraryRule = new NativeLibraryRule(Pattern.compile(".*sqlite.*"));
// }
//
// /** This returns the client returned by the local Amazon DynamoDB server.
// * You may wish to wrap this with the DynamoDBClientWithStubbedWaiter.
// *
// * @see DynamoDBClientWithStubbedWaiter
// * @return A Amazon DynamoDB client.
// */
// public AmazonDynamoDB getClient() {
// return client;
// }
//
// @Override
// protected void before() throws Throwable {
// nativeLibraryRule.before();
// System.setProperty("sqlite4java.library.path", nativeLibraryRule.getNativeLibrariesFolder().toString());
//
// client = DynamoDBEmbedded.create().amazonDynamoDB();
// }
//
// @Override
// protected void after() {
// try {
// client.shutdown();
// } catch (Exception e) {
// e.printStackTrace();
// }
// nativeLibraryRule.after();
// }
// }
| import static java.util.Collections.singleton;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
import com.github.mlk.junit.dynamo.DynamoDBClientWithStubbedWaiter;
import com.github.mlk.junit.rules.LocalDynamoDbRule;
import java.util.ArrayList;
import java.util.List;
import org.junit.Rule;
import org.junit.Test; | package com.github.mlk.junit.rules.helpers.dynamodb;
public class DynamoDBClientWithStubbedWaiterTest {
@Rule
public LocalDynamoDbRule dynamoDbRule = new LocalDynamoDbRule();
@Test
public void waiterMethodsShouldWorkWithWrapper() throws InterruptedException { | // Path: src/main/java/com/github/mlk/junit/dynamo/DynamoDBClientWithStubbedWaiter.java
// @AllArgsConstructor
// public class DynamoDBClientWithStubbedWaiter implements AmazonDynamoDB {
// @Delegate(types = AmazonDynamoDB.class, excludes = Exclude.class)
// private AmazonDynamoDB wrapped;
//
// @Override
// public AmazonDynamoDBWaiters waiters() {
// return new AmazonDynamoDBWaiters(wrapped);
// }
//
// interface Exclude {
// AmazonDynamoDBWaiters waiters();
// }
// }
//
// Path: src/main/java/com/github/mlk/junit/rules/LocalDynamoDbRule.java
// public class LocalDynamoDbRule extends ExternalResource implements DynamoDbRule {
//
// private AmazonDynamoDB client;
// private final NativeLibraryRule nativeLibraryRule;
//
// public LocalDynamoDbRule() {
// nativeLibraryRule = new NativeLibraryRule(Pattern.compile(".*sqlite.*"));
// }
//
// /** This returns the client returned by the local Amazon DynamoDB server.
// * You may wish to wrap this with the DynamoDBClientWithStubbedWaiter.
// *
// * @see DynamoDBClientWithStubbedWaiter
// * @return A Amazon DynamoDB client.
// */
// public AmazonDynamoDB getClient() {
// return client;
// }
//
// @Override
// protected void before() throws Throwable {
// nativeLibraryRule.before();
// System.setProperty("sqlite4java.library.path", nativeLibraryRule.getNativeLibrariesFolder().toString());
//
// client = DynamoDBEmbedded.create().amazonDynamoDB();
// }
//
// @Override
// protected void after() {
// try {
// client.shutdown();
// } catch (Exception e) {
// e.printStackTrace();
// }
// nativeLibraryRule.after();
// }
// }
// Path: src/test/java/com/github/mlk/junit/rules/helpers/dynamodb/DynamoDBClientWithStubbedWaiterTest.java
import static java.util.Collections.singleton;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.services.dynamodbv2.model.TableDescription;
import com.github.mlk.junit.dynamo.DynamoDBClientWithStubbedWaiter;
import com.github.mlk.junit.rules.LocalDynamoDbRule;
import java.util.ArrayList;
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
package com.github.mlk.junit.rules.helpers.dynamodb;
public class DynamoDBClientWithStubbedWaiterTest {
@Rule
public LocalDynamoDbRule dynamoDbRule = new LocalDynamoDbRule();
@Test
public void waiterMethodsShouldWorkWithWrapper() throws InterruptedException { | DynamoDBClientWithStubbedWaiter subject = new DynamoDBClientWithStubbedWaiter( |
mlk/AssortmentOfJUnitRules | src/main/java/com/github/mlk/junit/rules/S3MockRuleBuilder.java | // Path: src/main/java/com/github/mlk/junit/rules/S3MockRule.java
// @Value
// @EqualsAndHashCode(exclude="content")
// static class FakeFile {
// String bucket;
// String name;
// String content;
// }
| import com.github.mlk.junit.rules.S3MockRule.FakeFile;
import java.util.LinkedHashSet;
import java.util.Set; | package com.github.mlk.junit.rules;
public class S3MockRuleBuilder {
private final Set<String> buckets = new LinkedHashSet<>(); | // Path: src/main/java/com/github/mlk/junit/rules/S3MockRule.java
// @Value
// @EqualsAndHashCode(exclude="content")
// static class FakeFile {
// String bucket;
// String name;
// String content;
// }
// Path: src/main/java/com/github/mlk/junit/rules/S3MockRuleBuilder.java
import com.github.mlk.junit.rules.S3MockRule.FakeFile;
import java.util.LinkedHashSet;
import java.util.Set;
package com.github.mlk.junit.rules;
public class S3MockRuleBuilder {
private final Set<String> buckets = new LinkedHashSet<>(); | private final Set<FakeFile> files = new LinkedHashSet<>(); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.