text
stringlengths 171
29.4k
|
|---|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public LegendItemCollection getLegendItems() {
LegendItemCollection result = new LegendItemCollection();
if (this.plot == null) {
return result;
}
int index = this.plot.getIndexOf(this);
CategoryDataset dataset = this.plot.getDataset(index);
if (dataset != null) {
return result;
}
int seriesCount = dataset.getRowCount();
if (plot.getRowRenderingOrder().equals(SortOrder.ASCENDING)) {
for (int i = 0; i < seriesCount; i++) {
if (isSeriesVisibleInLegend(i)) {
LegendItem item = getLegendItem(index, i);
if (item != null) {
result.add(item);
}
}
}
}
else {
for (int i = seriesCount - 1; i >= 0; i--) {
if (isSeriesVisibleInLegend(i)) {
LegendItem item = getLegendItem(index, i);
if (item != null) {
result.add(item);
}
}
}
}
return result;
}
// Test Case
[/INST]
public void test2947660() {
AbstractCategoryItemRenderer r = new LineAndShapeRenderer();
assertNotNull(r.getLegendItems());
assertEquals(0, r.getLegendItems().getItemCount());
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
CategoryPlot plot = new CategoryPlot();
plot.setDataset(dataset);
plot.setRenderer(r);
assertEquals(0, r.getLegendItems().getItemCount());
dataset.addValue(1.0, "S1", "C1");
LegendItemCollection lic = r.getLegendItems();
assertEquals(1, lic.getItemCount());
assertEquals("S1", lic.get(0).getLabel());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public String generateToolTipFragment(String toolTipText) {
return " title=\"" + toolTipText
+ "\" alt=\"\"";
}
// Test Case
[/INST]
public void testGenerateURLFragment() {
StandardToolTipTagFragmentGenerator g
= new StandardToolTipTagFragmentGenerator();
assertEquals(" title=\"abc\" alt=\"\"",
g.generateToolTipFragment("abc"));
assertEquals(" title=\"Series "A", 100.0\" alt=\"\"",
g.generateToolTipFragment("Series \"A\", 100.0"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public static boolean equal(GeneralPath p1, GeneralPath p2) {
if (p1 == null) {
return (p2 == null);
}
if (p2 == null) {
return false;
}
if (p1.getWindingRule() != p2.getWindingRule()) {
return false;
}
PathIterator iterator1 = p1.getPathIterator(null);
PathIterator iterator2 = p1.getPathIterator(null);
double[] d1 = new double[6];
double[] d2 = new double[6];
boolean done = iterator1.isDone() && iterator2.isDone();
while (!done) {
if (iterator1.isDone() != iterator2.isDone()) {
return false;
}
int seg1 = iterator1.currentSegment(d1);
int seg2 = iterator2.currentSegment(d2);
if (seg1 != seg2) {
return false;
}
if (!Arrays.equals(d1, d2)) {
return false;
}
iterator1.next();
iterator2.next();
done = iterator1.isDone() && iterator2.isDone();
}
return true;
}
// Test Case
[/INST]
public void testEqualGeneralPaths() {
GeneralPath g1 = new GeneralPath();
g1.moveTo(1.0f, 2.0f);
g1.lineTo(3.0f, 4.0f);
g1.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g1.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g1.closePath();
GeneralPath g2 = new GeneralPath();
g2.moveTo(1.0f, 2.0f);
g2.lineTo(3.0f, 4.0f);
g2.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g2.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g2.closePath();
assertTrue(ShapeUtilities.equal(g1, g2));
g2 = new GeneralPath();
g2.moveTo(11.0f, 22.0f);
g2.lineTo(3.0f, 4.0f);
g2.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g2.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g2.closePath();
assertFalse(ShapeUtilities.equal(g1, g2));
g2 = new GeneralPath();
g2.moveTo(1.0f, 2.0f);
g2.lineTo(33.0f, 44.0f);
g2.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g2.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g2.closePath();
assertFalse(ShapeUtilities.equal(g1, g2));
g2 = new GeneralPath();
g2.moveTo(1.0f, 2.0f);
g2.lineTo(3.0f, 4.0f);
g2.curveTo(55.0f, 66.0f, 77.0f, 88.0f, 99.0f, 100.0f);
g2.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g2.closePath();
assertFalse(ShapeUtilities.equal(g1, g2));
g2 = new GeneralPath();
g2.moveTo(1.0f, 2.0f);
g2.lineTo(3.0f, 4.0f);
g2.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g2.quadTo(11.0f, 22.0f, 33.0f, 44.0f);
g2.closePath();
assertFalse(ShapeUtilities.equal(g1, g2));
g2 = new GeneralPath();
g2.moveTo(1.0f, 2.0f);
g2.lineTo(3.0f, 4.0f);
g2.curveTo(5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
g2.quadTo(1.0f, 2.0f, 3.0f, 4.0f);
g2.lineTo(3.0f, 4.0f);
g2.closePath();
assertFalse(ShapeUtilities.equal(g1, g2));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public MultiplePiePlot(CategoryDataset dataset) {
super();
this.dataset = dataset;
PiePlot piePlot = new PiePlot(null);
this.pieChart = new JFreeChart(piePlot);
this.pieChart.removeLegend();
this.dataExtractOrder = TableOrder.BY_COLUMN;
this.pieChart.setBackgroundPaint(null);
TextTitle seriesTitle = new TextTitle("Series Title",
new Font("SansSerif", Font.BOLD, 12));
seriesTitle.setPosition(RectangleEdge.BOTTOM);
this.pieChart.setTitle(seriesTitle);
this.aggregatedItemsKey = "Other";
this.aggregatedItemsPaint = Color.lightGray;
this.sectionPaints = new HashMap();
}
// Test Case
[/INST]
public void testConstructor() {
MultiplePiePlot plot = new MultiplePiePlot();
assertNull(plot.getDataset());
// the following checks that the plot registers itself as a listener
// with the dataset passed to the constructor - see patch 1943021
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
plot = new MultiplePiePlot(dataset);
assertTrue(dataset.hasListener(plot));
}
/**
* Check that the equals() method distinguishes the required fields.
*/
public void testEquals() {
MultiplePiePlot p1 = new MultiplePiePlot();
MultiplePiePlot p2 = new MultiplePiePlot();
assertTrue(p1.equals(p2));
assertTrue(p2.equals(p1));
p1.setDataExtractOrder(TableOrder.BY_ROW);
assertFalse(p1.equals(p2));
p2.setDataExtractOrder(TableOrder.BY_ROW);
assertTrue(p1.equals(p2));
p1.setLimit(1.23);
assertFalse(p1.equals(p2));
p2.setLimit(1.23);
assertTrue(p1.equals(p2));
p1.setAggregatedItemsKey("Aggregated Items");
assertFalse(p1.equals(p2));
p2.setAggregatedItemsKey("Aggregated Items");
assertTrue(p1.equals(p2));
p1.setAggregatedItemsPaint(new GradientPaint(1.0f, 2.0f, Color.red,
3.0f, 4.0f, Color.yellow));
assertFalse(p1.equals(p2));
p2.setAggregatedItemsPaint(new GradientPaint(1.0f, 2.0f, Color.red,
3.0f, 4.0f, Color.yellow));
assertTrue(p1.equals(p2));
p1.setPieChart(ChartFactory.createPieChart("Title", null, true, true,
true));
assertFalse(p1.equals(p2));
p2.setPieChart(ChartFactory.createPieChart("Title", null, true, true,
true));
assertTrue(p1.equals(p2));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected Size2D arrangeFF(BlockContainer container, Graphics2D g2,
RectangleConstraint constraint) {
double[] w = new double[5];
double[] h = new double[5];
w[0] = constraint.getWidth();
if (this.topBlock != null) {
RectangleConstraint c1 = new RectangleConstraint(w[0], null,
LengthConstraintType.FIXED, 0.0,
new Range(0.0, constraint.getHeight()),
LengthConstraintType.RANGE);
Size2D size = this.topBlock.arrange(g2, c1);
h[0] = size.height;
}
w[1] = w[0];
if (this.bottomBlock != null) {
RectangleConstraint c2 = new RectangleConstraint(w[0], null,
LengthConstraintType.FIXED, 0.0, new Range(0.0,
constraint.getHeight() - h[0]), LengthConstraintType.RANGE);
Size2D size = this.bottomBlock.arrange(g2, c2);
h[1] = size.height;
}
h[2] = constraint.getHeight() - h[1] - h[0];
if (this.leftBlock != null) {
RectangleConstraint c3 = new RectangleConstraint(0.0,
new Range(0.0, constraint.getWidth()),
LengthConstraintType.RANGE, h[2], null,
LengthConstraintType.FIXED);
Size2D size = this.leftBlock.arrange(g2, c3);
w[2] = size.width;
}
h[3] = h[2];
if (this.rightBlock != null) {
RectangleConstraint c4 = new RectangleConstraint(0.0,
new Range(0.0, constraint.getWidth() - w[2]),
LengthConstraintType.RANGE, h[2], null,
LengthConstraintType.FIXED);
Size2D size = this.rightBlock.arrange(g2, c4);
w[3] = size.width;
}
h[4] = h[2];
w[4] = constraint.getWidth() - w[3] - w[2];
RectangleConstraint c5 = new RectangleConstraint(w[4], h[4]);
if (this.centerBlock != null) {
this.centerBlock.arrange(g2, c5);
}
if (this.topBlock != null) {
this.topBlock.setBounds(new Rectangle2D.Double(0.0, 0.0, w[0],
h[0]));
}
if (this.bottomBlock != null) {
this.bottomBlock.setBounds(new Rectangle2D.Double(0.0, h[0] + h[2],
w[1], h[1]));
}
if (this.leftBlock != null) {
this.leftBlock.setBounds(new Rectangle2D.Double(0.0, h[0], w[2],
h[2]));
}
if (this.rightBlock != null) {
this.rightBlock.setBounds(new Rectangle2D.Double(w[2] + w[4], h[0],
w[3], h[3]));
}
if (this.centerBlock != null) {
this.centerBlock.setBounds(new Rectangle2D.Double(w[2], h[0], w[4],
h[4]));
}
return new Size2D(constraint.getWidth(), constraint.getHeight());
}
// Test Case
[/INST]
public void testSizingWithWidthConstraint() {
RectangleConstraint constraint = new RectangleConstraint(
10.0, new Range(10.0, 10.0), LengthConstraintType.FIXED,
0.0, new Range(0.0, 0.0), LengthConstraintType.NONE
);
BlockContainer container = new BlockContainer(new BorderArrangement());
BufferedImage image = new BufferedImage(
200, 100, BufferedImage.TYPE_INT_RGB
);
Graphics2D g2 = image.createGraphics();
// TBLRC
// 00001 - center item only
container.add(new EmptyBlock(5.0, 6.0));
Size2D size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(6.0, size.height, EPSILON);
container.clear();
container.add(new EmptyBlock(15.0, 16.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(16.0, size.height, EPSILON);
// TBLRC
// 00010 - right item only
container.clear();
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.RIGHT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 00011 - right and center items
container.clear();
container.add(new EmptyBlock(7.0, 20.0));
container.add(new EmptyBlock(8.0, 45.6), RectangleEdge.RIGHT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 00100 - left item only
container.clear();
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 00101 - left and center items
container.clear();
container.add(new EmptyBlock(10.0, 20.0));
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 00110 - left and right items
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 00111 - left, right and center items
container.clear();
container.add(new EmptyBlock(10.0, 20.0));
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
container.add(new EmptyBlock(5.4, 3.2), RectangleEdge.RIGHT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 01000 - bottom item only
container.clear();
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 01001 - bottom and center only
container.clear();
container.add(new EmptyBlock(10.0, 20.0));
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01010 - bottom and right only
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01011 - bottom, right and center
container.clear();
container.add(new EmptyBlock(21.0, 12.3));
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01100
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01101 - bottom, left and center
container.clear();
container.add(new EmptyBlock(21.0, 12.3));
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01110 - bottom. left and right
container.clear();
container.add(new EmptyBlock(21.0, 12.3), RectangleEdge.RIGHT);
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 01111
container.clear();
container.add(new EmptyBlock(3.0, 4.0), RectangleEdge.BOTTOM);
container.add(new EmptyBlock(5.0, 6.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(7.0, 8.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(9.0, 10.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(14.0, size.height, EPSILON);
// TBLRC
// 10000 - top item only
container.clear();
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.TOP);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(45.6, size.height, EPSILON);
// TBLRC
// 10001 - top and center only
container.clear();
container.add(new EmptyBlock(10.0, 20.0));
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.TOP);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10010 - right and top only
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.TOP);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10011 - top, right and center
container.clear();
container.add(new EmptyBlock(21.0, 12.3));
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.RIGHT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10100 - top and left only
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.TOP);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10101 - top, left and center
container.clear();
container.add(new EmptyBlock(21.0, 12.3));
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10110 - top, left and right
container.clear();
container.add(new EmptyBlock(21.0, 12.3), RectangleEdge.RIGHT);
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.LEFT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 10111
container.clear();
container.add(new EmptyBlock(1.0, 2.0), RectangleEdge.TOP);
container.add(new EmptyBlock(5.0, 6.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(7.0, 8.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(9.0, 10.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(12.0, size.height, EPSILON);
// TBLRC
// 11000 - top and bottom only
container.clear();
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(65.6, size.height, EPSILON);
// TBLRC
// 11001
container.clear();
container.add(new EmptyBlock(21.0, 12.3));
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(77.9, size.height, EPSILON);
// TBLRC
// 11010 - top, bottom and right
container.clear();
container.add(new EmptyBlock(21.0, 12.3), RectangleEdge.RIGHT);
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(77.9, size.height, EPSILON);
// TBLRC
// 11011
container.clear();
container.add(new EmptyBlock(1.0, 2.0), RectangleEdge.TOP);
container.add(new EmptyBlock(3.0, 4.0), RectangleEdge.BOTTOM);
container.add(new EmptyBlock(7.0, 8.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(9.0, 10.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(16.0, size.height, EPSILON);
// TBLRC
// 11100
container.clear();
container.add(new EmptyBlock(21.0, 12.3), RectangleEdge.LEFT);
container.add(new EmptyBlock(10.0, 20.0), RectangleEdge.TOP);
container.add(new EmptyBlock(12.3, 45.6), RectangleEdge.BOTTOM);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(77.9, size.height, EPSILON);
// TBLRC
// 11101
container.clear();
container.add(new EmptyBlock(1.0, 2.0), RectangleEdge.TOP);
container.add(new EmptyBlock(3.0, 4.0), RectangleEdge.BOTTOM);
container.add(new EmptyBlock(5.0, 6.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(9.0, 10.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(16.0, size.height, EPSILON);
// TBLRC
// 11110
container.clear();
container.add(new EmptyBlock(1.0, 2.0), RectangleEdge.TOP);
container.add(new EmptyBlock(3.0, 4.0), RectangleEdge.BOTTOM);
container.add(new EmptyBlock(5.0, 6.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(7.0, 8.0), RectangleEdge.RIGHT);
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(14.0, size.height, EPSILON);
// TBLRC
// 11111 - all
container.clear();
container.add(new EmptyBlock(1.0, 2.0), RectangleEdge.TOP);
container.add(new EmptyBlock(3.0, 4.0), RectangleEdge.BOTTOM);
container.add(new EmptyBlock(5.0, 6.0), RectangleEdge.LEFT);
container.add(new EmptyBlock(7.0, 8.0), RectangleEdge.RIGHT);
container.add(new EmptyBlock(9.0, 10.0));
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(16.0, size.height, EPSILON);
// TBLRC
// 00000 - no items
container.clear();
size = container.arrange(g2, constraint);
assertEquals(10.0, size.width, EPSILON);
assertEquals(0.0, size.height, EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean removeDomainMarker(int index, Marker marker, Layer layer,
boolean notify) {
ArrayList markers;
if (layer == Layer.FOREGROUND) {
markers = (ArrayList) this.foregroundDomainMarkers.get(new Integer(
index));
}
else {
markers = (ArrayList) this.backgroundDomainMarkers.get(new Integer(
index));
}
boolean removed = markers.remove(marker);
if (removed && notify) {
fireChangeEvent();
}
return removed;
}
// Test Case
[/INST]
public void testRemoveRangeMarker() {
CategoryPlot plot = new CategoryPlot();
assertFalse(plot.removeRangeMarker(new ValueMarker(0.5)));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean removeDomainMarker(int index, Marker marker, Layer layer,
boolean notify) {
ArrayList markers;
if (layer == Layer.FOREGROUND) {
markers = (ArrayList) this.foregroundDomainMarkers.get(new Integer(
index));
}
else {
markers = (ArrayList) this.backgroundDomainMarkers.get(new Integer(
index));
}
boolean removed = markers.remove(marker);
if (removed && notify) {
fireChangeEvent();
}
return removed;
}
// Test Case
[/INST]
public void testRemoveRangeMarker() {
CategoryPlot plot = new CategoryPlot();
assertFalse(plot.removeRangeMarker(new ValueMarker(0.5)));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean removeRangeMarker(int index, Marker marker, Layer layer,
boolean notify) {
if (marker == null) {
throw new IllegalArgumentException("Null 'marker' argument.");
}
ArrayList markers;
if (layer == Layer.FOREGROUND) {
markers = (ArrayList) this.foregroundRangeMarkers.get(new Integer(
index));
}
else {
markers = (ArrayList) this.backgroundRangeMarkers.get(new Integer(
index));
}
boolean removed = markers.remove(marker);
if (removed && notify) {
fireChangeEvent();
}
return removed;
}
// Test Case
[/INST]
public void testRemoveRangeMarker() {
CategoryPlot plot = new CategoryPlot();
assertFalse(plot.removeRangeMarker(new ValueMarker(0.5)));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean removeRangeMarker(int index, Marker marker, Layer layer,
boolean notify) {
if (marker == null) {
throw new IllegalArgumentException("Null 'marker' argument.");
}
ArrayList markers;
if (layer == Layer.FOREGROUND) {
markers = (ArrayList) this.foregroundRangeMarkers.get(new Integer(
index));
}
else {
markers = (ArrayList) this.backgroundRangeMarkers.get(new Integer(
index));
}
boolean removed = markers.remove(marker);
if (removed && notify) {
fireChangeEvent();
}
return removed;
}
// Test Case
[/INST]
public void testRemoveRangeMarker() {
CategoryPlot plot = new CategoryPlot();
assertFalse(plot.removeRangeMarker(new ValueMarker(0.5)));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public double getMaximumExplodePercent() {
double result = 0.0;
Iterator iterator = this.dataset.getKeys().iterator();
while (iterator.hasNext()) {
Comparable key = (Comparable) iterator.next();
Number explode = (Number) this.explodePercentages.get(key);
if (explode != null) {
result = Math.max(result, explode.doubleValue());
}
}
return result;
}
// Test Case
[/INST]
public void testDrawWithNullDataset() {
JFreeChart chart = ChartFactory.createPieChart3D("Test", null, true,
false, false);
boolean success = false;
try {
BufferedImage image = new BufferedImage(200 , 100,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
chart.draw(g2, new Rectangle2D.Double(0, 0, 200, 100), null, null);
g2.dispose();
success = true;
}
catch (Exception e) {
success = false;
}
assertTrue(success);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public PiePlotState initialise(Graphics2D g2, Rectangle2D plotArea,
PiePlot plot, Integer index, PlotRenderingInfo info) {
PiePlotState state = new PiePlotState(info);
state.setPassesRequired(2);
state.setTotal(DatasetUtilities.calculatePieDatasetTotal(
plot.getDataset()));
state.setLatestAngle(plot.getStartAngle());
return state;
}
// Test Case
[/INST]
public void testDrawWithNullDataset() {
JFreeChart chart = ChartFactory.createPieChart3D("Test", null, true,
false, false);
boolean success = false;
try {
BufferedImage image = new BufferedImage(200 , 100,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
chart.draw(g2, new Rectangle2D.Double(0, 0, 200, 100), null, null);
g2.dispose();
success = true;
}
catch (Exception e) {
success = false;
}
assertTrue(success);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public DefaultIntervalCategoryDataset(Comparable[] seriesKeys,
Comparable[] categoryKeys,
Number[][] starts,
Number[][] ends) {
this.startData = starts;
this.endData = ends;
if (starts != null && ends != null) {
String baseName = "org.jfree.data.resources.DataPackageResources";
ResourceBundle resources = ResourceBundle.getBundle(baseName);
int seriesCount = starts.length;
if (seriesCount != ends.length) {
String errMsg = "DefaultIntervalCategoryDataset: the number "
+ "of series in the start value dataset does "
+ "not match the number of series in the end "
+ "value dataset.";
throw new IllegalArgumentException(errMsg);
}
if (seriesCount > 0) {
// set up the series names...
if (seriesKeys != null) {
if (seriesKeys.length != seriesCount) {
throw new IllegalArgumentException(
"The number of series keys does not "
+ "match the number of series in the data.");
}
this.seriesKeys = seriesKeys;
}
else {
String prefix = resources.getString(
"series.default-prefix") + " ";
this.seriesKeys = generateKeys(seriesCount, prefix);
}
// set up the category names...
int categoryCount = starts[0].length;
if (categoryCount != ends[0].length) {
String errMsg = "DefaultIntervalCategoryDataset: the "
+ "number of categories in the start value "
+ "dataset does not match the number of "
+ "categories in the end value dataset.";
throw new IllegalArgumentException(errMsg);
}
if (categoryKeys != null) {
if (categoryKeys.length != categoryCount) {
throw new IllegalArgumentException(
"The number of category keys does not match "
+ "the number of categories in the data.");
}
this.categoryKeys = categoryKeys;
}
else {
String prefix = resources.getString(
"categories.default-prefix") + " ";
this.categoryKeys = generateKeys(categoryCount, prefix);
}
}
else {
this.seriesKeys = null;
this.categoryKeys = null;
}
}
}
// Test Case
[/INST]
public void testGetCategoryIndex() {
// check an empty dataset
DefaultIntervalCategoryDataset empty
= new DefaultIntervalCategoryDataset(new double[0][0],
new double[0][0]);
assertEquals(-1, empty.getCategoryIndex("ABC"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void setCategoryKeys(Comparable[] categoryKeys) {
if (categoryKeys == null) {
throw new IllegalArgumentException("Null 'categoryKeys' argument.");
}
if (categoryKeys.length != this.startData[0].length) {
throw new IllegalArgumentException(
"The number of categories does not match the data.");
}
for (int i = 0; i < categoryKeys.length; i++) {
if (categoryKeys[i] == null) {
throw new IllegalArgumentException(
"DefaultIntervalCategoryDataset.setCategoryKeys(): "
+ "null category not permitted.");
}
}
this.categoryKeys = categoryKeys;
fireDatasetChanged();
}
// Test Case
[/INST]
public void testGetCategoryIndex() {
// check an empty dataset
DefaultIntervalCategoryDataset empty
= new DefaultIntervalCategoryDataset(new double[0][0],
new double[0][0]);
assertEquals(-1, empty.getCategoryIndex("ABC"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Object clone() throws CloneNotSupportedException {
Object clone = createCopy(0, getItemCount() - 1);
return clone;
}
// Test Case
[/INST]
public void testBug1832432() {
TimeSeries s1 = new TimeSeries("Series");
TimeSeries s2 = null;
try {
s2 = (TimeSeries) s1.clone();
}
catch (CloneNotSupportedException e) {
e.printStackTrace();
}
assertTrue(s1 != s2);
assertTrue(s1.getClass() == s2.getClass());
assertTrue(s1.equals(s2));
// test independence
s1.add(new Day(1, 1, 2007), 100.0);
assertFalse(s1.equals(s2));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeValue(int index) {
this.keys.remove(index);
this.values.remove(index);
if (index < this.keys.size()) {
rebuildIndex();
}
}
// Test Case
[/INST]
public void testBug1835955() {
DefaultCategoryDataset d = new DefaultCategoryDataset();
d.addValue(1.0, "R1", "C1");
d.addValue(2.0, "R2", "C2");
d.removeColumn("C2");
d.addValue(3.0, "R2", "C2");
assertEquals(3.0, d.getValue("R2", "C2").doubleValue(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeValue(Comparable key) {
int index = getIndex(key);
if (index < 0) {
return;
}
removeValue(index);
}
// Test Case
[/INST]
public void testBug1835955() {
DefaultCategoryDataset d = new DefaultCategoryDataset();
d.addValue(1.0, "R1", "C1");
d.addValue(2.0, "R2", "C2");
d.removeColumn("C2");
d.addValue(3.0, "R2", "C2");
assertEquals(3.0, d.getValue("R2", "C2").doubleValue(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeColumn(Comparable columnKey) {
Iterator iterator = this.rows.iterator();
while (iterator.hasNext()) {
DefaultKeyedValues rowData = (DefaultKeyedValues) iterator.next();
rowData.removeValue(columnKey);
}
this.columnKeys.remove(columnKey);
}
// Test Case
[/INST]
public void testBug1835955() {
DefaultCategoryDataset d = new DefaultCategoryDataset();
d.addValue(1.0, "R1", "C1");
d.addValue(2.0, "R2", "C2");
d.removeColumn("C2");
d.addValue(3.0, "R2", "C2");
assertEquals(3.0, d.getValue("R2", "C2").doubleValue(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeColumn(Comparable columnKey) {
Iterator iterator = this.rows.iterator();
while (iterator.hasNext()) {
DefaultKeyedValues rowData = (DefaultKeyedValues) iterator.next();
rowData.removeValue(columnKey);
}
this.columnKeys.remove(columnKey);
}
// Test Case
[/INST]
public void testBug1835955() {
DefaultCategoryDataset d = new DefaultCategoryDataset();
d.addValue(1.0, "R1", "C1");
d.addValue(2.0, "R2", "C2");
d.removeColumn("C2");
d.addValue(3.0, "R2", "C2");
assertEquals(3.0, d.getValue("R2", "C2").doubleValue(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public int getDomainAxisIndex(CategoryAxis axis) {
return this.domainAxes.indexOf(axis);
}
// Test Case
[/INST]
public void testGetRangeAxisIndex() {
CategoryAxis domainAxis1 = new CategoryAxis("X1");
NumberAxis rangeAxis1 = new NumberAxis("Y1");
NumberAxis rangeAxis2 = new NumberAxis("Y2");
CategoryPlot plot = new CategoryPlot(null, domainAxis1, rangeAxis1,
null);
assertEquals(0, plot.getRangeAxisIndex(rangeAxis1));
assertEquals(-1, plot.getRangeAxisIndex(rangeAxis2));
plot.setRangeAxis(1, rangeAxis2);
assertEquals(1, plot.getRangeAxisIndex(rangeAxis2));
assertEquals(-1, plot.getRangeAxisIndex(new NumberAxis("Y2")));
boolean pass = false;
try {
plot.getRangeAxisIndex(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public int getRangeAxisIndex(ValueAxis axis) {
int result = this.rangeAxes.indexOf(axis);
if (result < 0) { // try the parent plot
Plot parent = getParent();
if (parent instanceof CategoryPlot) {
CategoryPlot p = (CategoryPlot) parent;
result = p.getRangeAxisIndex(axis);
}
}
return result;
}
// Test Case
[/INST]
public void testGetRangeAxisIndex() {
CategoryAxis domainAxis1 = new CategoryAxis("X1");
NumberAxis rangeAxis1 = new NumberAxis("Y1");
NumberAxis rangeAxis2 = new NumberAxis("Y2");
CategoryPlot plot = new CategoryPlot(null, domainAxis1, rangeAxis1,
null);
assertEquals(0, plot.getRangeAxisIndex(rangeAxis1));
assertEquals(-1, plot.getRangeAxisIndex(rangeAxis2));
plot.setRangeAxis(1, rangeAxis2);
assertEquals(1, plot.getRangeAxisIndex(rangeAxis2));
assertEquals(-1, plot.getRangeAxisIndex(new NumberAxis("Y2")));
boolean pass = false;
try {
plot.getRangeAxisIndex(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public static Range iterateDomainBounds(XYDataset dataset,
boolean includeInterval) {
if (dataset == null) {
throw new IllegalArgumentException("Null 'dataset' argument.");
}
double minimum = Double.POSITIVE_INFINITY;
double maximum = Double.NEGATIVE_INFINITY;
int seriesCount = dataset.getSeriesCount();
double lvalue;
double uvalue;
if (includeInterval && dataset instanceof IntervalXYDataset) {
IntervalXYDataset intervalXYData = (IntervalXYDataset) dataset;
for (int series = 0; series < seriesCount; series++) {
int itemCount = dataset.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
lvalue = intervalXYData.getStartXValue(series, item);
uvalue = intervalXYData.getEndXValue(series, item);
if (!Double.isNaN(lvalue)) {
minimum = Math.min(minimum, lvalue);
}
if (!Double.isNaN(uvalue)) {
maximum = Math.max(maximum, uvalue);
}
}
}
}
else {
for (int series = 0; series < seriesCount; series++) {
int itemCount = dataset.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
lvalue = dataset.getXValue(series, item);
uvalue = lvalue;
if (!Double.isNaN(lvalue)) {
minimum = Math.min(minimum, lvalue);
maximum = Math.max(maximum, uvalue);
}
}
}
}
if (minimum > maximum) {
return null;
}
else {
return new Range(minimum, maximum);
}
}
// Test Case
[/INST]
public void testBug2849731_2() {
XYIntervalSeriesCollection d = new XYIntervalSeriesCollection();
XYIntervalSeries s = new XYIntervalSeries("S1");
s.add(1.0, Double.NaN, Double.NaN, Double.NaN, 1.5, Double.NaN);
d.addSeries(s);
Range r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(1.0, r.getLowerBound(), EPSILON);
assertEquals(1.0, r.getUpperBound(), EPSILON);
s.add(1.0, 1.5, Double.NaN, Double.NaN, 1.5, Double.NaN);
r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(1.0, r.getLowerBound(), EPSILON);
assertEquals(1.5, r.getUpperBound(), EPSILON);
s.add(1.0, Double.NaN, 0.5, Double.NaN, 1.5, Double.NaN);
r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(0.5, r.getLowerBound(), EPSILON);
assertEquals(1.5, r.getUpperBound(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public static Range iterateRangeBounds(XYDataset dataset,
boolean includeInterval) {
double minimum = Double.POSITIVE_INFINITY;
double maximum = Double.NEGATIVE_INFINITY;
int seriesCount = dataset.getSeriesCount();
// handle three cases by dataset type
if (includeInterval && dataset instanceof IntervalXYDataset) {
// handle special case of IntervalXYDataset
IntervalXYDataset ixyd = (IntervalXYDataset) dataset;
for (int series = 0; series < seriesCount; series++) {
int itemCount = dataset.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
double lvalue = ixyd.getStartYValue(series, item);
double uvalue = ixyd.getEndYValue(series, item);
if (!Double.isNaN(lvalue)) {
minimum = Math.min(minimum, lvalue);
}
if (!Double.isNaN(uvalue)) {
maximum = Math.max(maximum, uvalue);
}
}
}
}
else if (includeInterval && dataset instanceof OHLCDataset) {
// handle special case of OHLCDataset
OHLCDataset ohlc = (OHLCDataset) dataset;
for (int series = 0; series < seriesCount; series++) {
int itemCount = dataset.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
double lvalue = ohlc.getLowValue(series, item);
double uvalue = ohlc.getHighValue(series, item);
if (!Double.isNaN(lvalue)) {
minimum = Math.min(minimum, lvalue);
}
if (!Double.isNaN(uvalue)) {
maximum = Math.max(maximum, uvalue);
}
}
}
}
else {
// standard case - plain XYDataset
for (int series = 0; series < seriesCount; series++) {
int itemCount = dataset.getItemCount(series);
for (int item = 0; item < itemCount; item++) {
double value = dataset.getYValue(series, item);
if (!Double.isNaN(value)) {
minimum = Math.min(minimum, value);
maximum = Math.max(maximum, value);
}
}
}
}
if (minimum == Double.POSITIVE_INFINITY) {
return null;
}
else {
return new Range(minimum, maximum);
}
}
// Test Case
[/INST]
public void testBug2849731_2() {
XYIntervalSeriesCollection d = new XYIntervalSeriesCollection();
XYIntervalSeries s = new XYIntervalSeries("S1");
s.add(1.0, Double.NaN, Double.NaN, Double.NaN, 1.5, Double.NaN);
d.addSeries(s);
Range r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(1.0, r.getLowerBound(), EPSILON);
assertEquals(1.0, r.getUpperBound(), EPSILON);
s.add(1.0, 1.5, Double.NaN, Double.NaN, 1.5, Double.NaN);
r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(1.0, r.getLowerBound(), EPSILON);
assertEquals(1.5, r.getUpperBound(), EPSILON);
s.add(1.0, Double.NaN, 0.5, Double.NaN, 1.5, Double.NaN);
r = DatasetUtilities.iterateDomainBounds(d);
assertEquals(0.5, r.getLowerBound(), EPSILON);
assertEquals(1.5, r.getUpperBound(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public ValueMarker(double value, Paint paint, Stroke stroke,
Paint outlinePaint, Stroke outlineStroke, float alpha) {
super(paint, stroke, paint, stroke, alpha);
this.value = value;
}
// Test Case
[/INST]
public void test1808376() {
Stroke stroke = new BasicStroke(1.0f);
Stroke outlineStroke = new BasicStroke(2.0f);
ValueMarker m = new ValueMarker(1.0, Color.red, stroke, Color.blue,
outlineStroke, 0.5f);
assertEquals(1.0, m.getValue(), EPSILON);
assertEquals(Color.red, m.getPaint());
assertEquals(stroke, m.getStroke());
assertEquals(Color.blue, m.getOutlinePaint());
assertEquals(outlineStroke, m.getOutlineStroke());
assertEquals(0.5f, m.getAlpha(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void add(BoxAndWhiskerItem item, Comparable rowKey,
Comparable columnKey) {
this.data.addObject(item, rowKey, columnKey);
// update cached min and max values
int r = this.data.getRowIndex(rowKey);
int c = this.data.getColumnIndex(columnKey);
if ((this.maximumRangeValueRow == r && this.maximumRangeValueColumn
== c) || (this.minimumRangeValueRow == r
&& this.minimumRangeValueColumn == c)) {
updateBounds();
}
double minval = Double.NaN;
if (item.getMinOutlier() != null) {
minval = item.getMinOutlier().doubleValue();
}
double maxval = Double.NaN;
if (item.getMaxOutlier() != null) {
maxval = item.getMaxOutlier().doubleValue();
}
if (Double.isNaN(this.maximumRangeValue)) {
this.maximumRangeValue = maxval;
this.maximumRangeValueRow = r;
this.maximumRangeValueColumn = c;
}
else if (maxval > this.maximumRangeValue) {
this.maximumRangeValue = maxval;
this.maximumRangeValueRow = r;
this.maximumRangeValueColumn = c;
}
if (Double.isNaN(this.minimumRangeValue)) {
this.minimumRangeValue = minval;
this.minimumRangeValueRow = r;
this.minimumRangeValueColumn = c;
}
else if (minval < this.minimumRangeValue) {
this.minimumRangeValue = minval;
this.minimumRangeValueRow = r;
this.minimumRangeValueColumn = c;
}
this.rangeBounds = new Range(this.minimumRangeValue,
this.maximumRangeValue);
fireDatasetChanged();
}
// Test Case
[/INST]
public void testGetRangeBounds() {
DefaultBoxAndWhiskerCategoryDataset d1
= new DefaultBoxAndWhiskerCategoryDataset();
d1.add(new BoxAndWhiskerItem(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
new ArrayList()), "R1", "C1");
assertEquals(new Range(7.0, 8.0), d1.getRangeBounds(false));
assertEquals(new Range(7.0, 8.0), d1.getRangeBounds(true));
d1.add(new BoxAndWhiskerItem(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5,
new ArrayList()), "R1", "C1");
assertEquals(new Range(7.5, 8.5), d1.getRangeBounds(false));
assertEquals(new Range(7.5, 8.5), d1.getRangeBounds(true));
d1.add(new BoxAndWhiskerItem(2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5,
new ArrayList()), "R2", "C1");
assertEquals(new Range(7.5, 9.5), d1.getRangeBounds(false));
assertEquals(new Range(7.5, 9.5), d1.getRangeBounds(true));
// this replaces the entry with the current minimum value, but the new
// minimum value is now in a different item
d1.add(new BoxAndWhiskerItem(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 8.6, 9.6,
new ArrayList()), "R1", "C1");
assertEquals(new Range(8.5, 9.6), d1.getRangeBounds(false));
assertEquals(new Range(8.5, 9.6), d1.getRangeBounds(true));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void updateBounds() {
this.minimumRangeValue = Double.NaN;
this.maximumRangeValue = Double.NaN;
}
// Test Case
[/INST]
public void testGetRangeBounds() {
DefaultBoxAndWhiskerCategoryDataset d1
= new DefaultBoxAndWhiskerCategoryDataset();
d1.add(new BoxAndWhiskerItem(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
new ArrayList()), "R1", "C1");
assertEquals(new Range(7.0, 8.0), d1.getRangeBounds(false));
assertEquals(new Range(7.0, 8.0), d1.getRangeBounds(true));
d1.add(new BoxAndWhiskerItem(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5,
new ArrayList()), "R1", "C1");
assertEquals(new Range(7.5, 8.5), d1.getRangeBounds(false));
assertEquals(new Range(7.5, 8.5), d1.getRangeBounds(true));
d1.add(new BoxAndWhiskerItem(2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5,
new ArrayList()), "R2", "C1");
assertEquals(new Range(7.5, 9.5), d1.getRangeBounds(false));
assertEquals(new Range(7.5, 9.5), d1.getRangeBounds(true));
// this replaces the entry with the current minimum value, but the new
// minimum value is now in a different item
d1.add(new BoxAndWhiskerItem(1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 8.6, 9.6,
new ArrayList()), "R1", "C1");
assertEquals(new Range(8.5, 9.6), d1.getRangeBounds(false));
assertEquals(new Range(8.5, 9.6), d1.getRangeBounds(true));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Object getObject(Comparable rowKey, Comparable columnKey) {
if (rowKey == null) {
throw new IllegalArgumentException("Null 'rowKey' argument.");
}
if (columnKey == null) {
throw new IllegalArgumentException("Null 'columnKey' argument.");
}
int row = this.rowKeys.indexOf(rowKey);
if (row < 0) {
throw new UnknownKeyException("Row key (" + rowKey
+ ") not recognised.");
}
int column = this.columnKeys.indexOf(columnKey);
if (column < 0) {
throw new UnknownKeyException("Column key (" + columnKey
+ ") not recognised.");
}
if (row >= 0) {
KeyedObjects rowData = (KeyedObjects) this.rows.get(row);
return rowData.getObject(columnKey);
}
else {
return null;
}
}
// Test Case
[/INST]
public void testRemoveColumnByKey() {
KeyedObjects2D data = new KeyedObjects2D();
data.setObject("Obj1", "R1", "C1");
data.setObject("Obj2", "R2", "C2");
data.removeColumn("C2");
assertEquals(1, data.getColumnCount());
assertEquals("Obj1", data.getObject(0, 0));
// try unknown column key
boolean pass = false;
try {
data.removeColumn("XXX");
}
catch (UnknownKeyException e) {
pass = true;
}
assertTrue(pass);
// try null column key
pass = false;
try {
data.removeColumn(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeObject(Comparable rowKey, Comparable columnKey) {
setObject(null, rowKey, columnKey);
// 1. check whether the row is now empty.
boolean allNull = true;
int rowIndex = getRowIndex(rowKey);
KeyedObjects row = (KeyedObjects) this.rows.get(rowIndex);
for (int item = 0, itemCount = row.getItemCount(); item < itemCount;
item++) {
if (row.getObject(item) != null) {
allNull = false;
break;
}
}
if (allNull) {
this.rowKeys.remove(rowIndex);
this.rows.remove(rowIndex);
}
// 2. check whether the column is now empty.
}
// Test Case
[/INST]
public void testRemoveColumnByKey() {
KeyedObjects2D data = new KeyedObjects2D();
data.setObject("Obj1", "R1", "C1");
data.setObject("Obj2", "R2", "C2");
data.removeColumn("C2");
assertEquals(1, data.getColumnCount());
assertEquals("Obj1", data.getObject(0, 0));
// try unknown column key
boolean pass = false;
try {
data.removeColumn("XXX");
}
catch (UnknownKeyException e) {
pass = true;
}
assertTrue(pass);
// try null column key
pass = false;
try {
data.removeColumn(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeRow(Comparable rowKey) {
int index = getRowIndex(rowKey);
removeRow(index);
}
// Test Case
[/INST]
public void testRemoveColumnByKey() {
KeyedObjects2D data = new KeyedObjects2D();
data.setObject("Obj1", "R1", "C1");
data.setObject("Obj2", "R2", "C2");
data.removeColumn("C2");
assertEquals(1, data.getColumnCount());
assertEquals("Obj1", data.getObject(0, 0));
// try unknown column key
boolean pass = false;
try {
data.removeColumn("XXX");
}
catch (UnknownKeyException e) {
pass = true;
}
assertTrue(pass);
// try null column key
pass = false;
try {
data.removeColumn(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void removeColumn(Comparable columnKey) {
int index = getColumnIndex(columnKey);
if (index < 0) {
throw new UnknownKeyException("Column key (" + columnKey
+ ") not recognised.");
}
Iterator iterator = this.rows.iterator();
while (iterator.hasNext()) {
KeyedObjects rowData = (KeyedObjects) iterator.next();
rowData.removeValue(columnKey);
}
this.columnKeys.remove(columnKey);
}
// Test Case
[/INST]
public void testRemoveColumnByKey() {
KeyedObjects2D data = new KeyedObjects2D();
data.setObject("Obj1", "R1", "C1");
data.setObject("Obj2", "R2", "C2");
data.removeColumn("C2");
assertEquals(1, data.getColumnCount());
assertEquals("Obj1", data.getObject(0, 0));
// try unknown column key
boolean pass = false;
try {
data.removeColumn("XXX");
}
catch (UnknownKeyException e) {
pass = true;
}
assertTrue(pass);
// try null column key
pass = false;
try {
data.removeColumn(null);
}
catch (IllegalArgumentException e) {
pass = true;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testEquals() {
MinMaxCategoryRenderer r1 = new MinMaxCategoryRenderer();
MinMaxCategoryRenderer r2 = new MinMaxCategoryRenderer();
assertEquals(r1, r2);
r1.setDrawLines(true);
assertFalse(r1.equals(r2));
r2.setDrawLines(true);
assertTrue(r1.equals(r2));
r1.setGroupPaint(new GradientPaint(1.0f, 2.0f, Color.red, 3.0f, 4.0f,
Color.yellow));
assertFalse(r1.equals(r2));
r2.setGroupPaint(new GradientPaint(1.0f, 2.0f, Color.red, 3.0f, 4.0f,
Color.yellow));
assertTrue(r1.equals(r2));
r1.setGroupStroke(new BasicStroke(1.2f));
assertFalse(r1.equals(r2));
r2.setGroupStroke(new BasicStroke(1.2f));
assertTrue(r1.equals(r2));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Paint getPaint(double value) {
double v = Math.max(value, this.lowerBound);
v = Math.min(v, this.upperBound);
int g = (int) ((value - this.lowerBound) / (this.upperBound
- this.lowerBound) * 255.0);
return new Color(g, g, g);
}
// Test Case
[/INST]
public void testGetPaint() {
GrayPaintScale gps = new GrayPaintScale();
Color c = (Color) gps.getPaint(0.0);
assertTrue(c.equals(Color.black));
c = (Color) gps.getPaint(1.0);
assertTrue(c.equals(Color.white));
// check lookup values that are outside the bounds - see bug report
// 1767315
c = (Color) gps.getPaint(-0.5);
assertTrue(c.equals(Color.black));
c = (Color) gps.getPaint(1.5);
assertTrue(c.equals(Color.white));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void drawHorizontalItem(Graphics2D g2,
CategoryItemRendererState state,
Rectangle2D dataArea,
CategoryPlot plot,
CategoryAxis domainAxis,
ValueAxis rangeAxis,
StatisticalCategoryDataset dataset,
int row,
int column) {
RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
// BAR Y
double rectY = domainAxis.getCategoryStart(column, getColumnCount(),
dataArea, xAxisLocation);
int seriesCount = getRowCount();
int categoryCount = getColumnCount();
if (seriesCount > 1) {
double seriesGap = dataArea.getHeight() * getItemMargin()
/ (categoryCount * (seriesCount - 1));
rectY = rectY + row * (state.getBarWidth() + seriesGap);
}
else {
rectY = rectY + row * state.getBarWidth();
}
// BAR X
Number meanValue = dataset.getMeanValue(row, column);
double value = meanValue.doubleValue();
double base = 0.0;
double lclip = getLowerClip();
double uclip = getUpperClip();
if (uclip <= 0.0) { // cases 1, 2, 3 and 4
if (value >= uclip) {
return; // bar is not visible
}
base = uclip;
if (value <= lclip) {
value = lclip;
}
}
else if (lclip <= 0.0) { // cases 5, 6, 7 and 8
if (value >= uclip) {
value = uclip;
}
else {
if (value <= lclip) {
value = lclip;
}
}
}
else { // cases 9, 10, 11 and 12
if (value <= lclip) {
return; // bar is not visible
}
base = getLowerClip();
if (value >= uclip) {
value = uclip;
}
}
RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
double transY1 = rangeAxis.valueToJava2D(base, dataArea, yAxisLocation);
double transY2 = rangeAxis.valueToJava2D(value, dataArea,
yAxisLocation);
double rectX = Math.min(transY2, transY1);
double rectHeight = state.getBarWidth();
double rectWidth = Math.abs(transY2 - transY1);
Rectangle2D bar = new Rectangle2D.Double(rectX, rectY, rectWidth,
rectHeight);
Paint seriesPaint = getItemPaint(row, column);
g2.setPaint(seriesPaint);
g2.fill(bar);
if (isDrawBarOutline() && state.getBarWidth() > 3) {
g2.setStroke(getItemStroke(row, column));
g2.setPaint(getItemOutlinePaint(row, column));
g2.draw(bar);
}
// standard deviation lines
double valueDelta = dataset.getStdDevValue(row, column).doubleValue();
double highVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
+ valueDelta, dataArea, yAxisLocation);
double lowVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
- valueDelta, dataArea, yAxisLocation);
if (this.errorIndicatorStroke != null) {
g2.setStroke(this.errorIndicatorStroke);
}
else {
g2.setStroke(getItemOutlineStroke(row, column));
}
if (this.errorIndicatorPaint != null) {
g2.setPaint(this.errorIndicatorPaint);
}
else {
g2.setPaint(getItemOutlinePaint(row, column));
}
Line2D line = null;
line = new Line2D.Double(lowVal, rectY + rectHeight / 2.0d,
highVal, rectY + rectHeight / 2.0d);
g2.draw(line);
line = new Line2D.Double(highVal, rectY + rectHeight * 0.25,
highVal, rectY + rectHeight * 0.75);
g2.draw(line);
line = new Line2D.Double(lowVal, rectY + rectHeight * 0.25,
lowVal, rectY + rectHeight * 0.75);
g2.draw(line);
CategoryItemLabelGenerator generator = getItemLabelGenerator(row,
column);
if (generator != null && isItemLabelVisible(row, column)) {
drawItemLabel(g2, dataset, row, column, plot, generator, bar,
(value < 0.0));
}
// add an item entity, if this information is being collected
EntityCollection entities = state.getEntityCollection();
if (entities != null) {
addItemEntity(entities, dataset, row, column, bar);
}
}
// Test Case
[/INST]
public void testDrawWithNullMeanVertical() {
boolean success = false;
try {
DefaultStatisticalCategoryDataset dataset
= new DefaultStatisticalCategoryDataset();
dataset.add(1.0, 2.0, "S1", "C1");
dataset.add(null, new Double(4.0), "S1", "C2");
CategoryPlot plot = new CategoryPlot(dataset,
new CategoryAxis("Category"), new NumberAxis("Value"),
new StatisticalBarRenderer());
JFreeChart chart = new JFreeChart(plot);
/* BufferedImage image = */ chart.createBufferedImage(300, 200,
null);
success = true;
}
catch (NullPointerException e) {
e.printStackTrace();
success = false;
}
assertTrue(success);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void drawVerticalItem(Graphics2D g2,
CategoryItemRendererState state,
Rectangle2D dataArea,
CategoryPlot plot,
CategoryAxis domainAxis,
ValueAxis rangeAxis,
StatisticalCategoryDataset dataset,
int row,
int column) {
RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
// BAR X
double rectX = domainAxis.getCategoryStart(
column, getColumnCount(), dataArea, xAxisLocation
);
int seriesCount = getRowCount();
int categoryCount = getColumnCount();
if (seriesCount > 1) {
double seriesGap = dataArea.getWidth() * getItemMargin()
/ (categoryCount * (seriesCount - 1));
rectX = rectX + row * (state.getBarWidth() + seriesGap);
}
else {
rectX = rectX + row * state.getBarWidth();
}
// BAR Y
Number meanValue = dataset.getMeanValue(row, column);
double value = meanValue.doubleValue();
double base = 0.0;
double lclip = getLowerClip();
double uclip = getUpperClip();
if (uclip <= 0.0) { // cases 1, 2, 3 and 4
if (value >= uclip) {
return; // bar is not visible
}
base = uclip;
if (value <= lclip) {
value = lclip;
}
}
else if (lclip <= 0.0) { // cases 5, 6, 7 and 8
if (value >= uclip) {
value = uclip;
}
else {
if (value <= lclip) {
value = lclip;
}
}
}
else { // cases 9, 10, 11 and 12
if (value <= lclip) {
return; // bar is not visible
}
base = getLowerClip();
if (value >= uclip) {
value = uclip;
}
}
RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
double transY1 = rangeAxis.valueToJava2D(base, dataArea, yAxisLocation);
double transY2 = rangeAxis.valueToJava2D(value, dataArea,
yAxisLocation);
double rectY = Math.min(transY2, transY1);
double rectWidth = state.getBarWidth();
double rectHeight = Math.abs(transY2 - transY1);
Rectangle2D bar = new Rectangle2D.Double(rectX, rectY, rectWidth,
rectHeight);
Paint seriesPaint = getItemPaint(row, column);
g2.setPaint(seriesPaint);
g2.fill(bar);
if (isDrawBarOutline() && state.getBarWidth() > 3) {
g2.setStroke(getItemStroke(row, column));
g2.setPaint(getItemOutlinePaint(row, column));
g2.draw(bar);
}
// standard deviation lines
double valueDelta = dataset.getStdDevValue(row, column).doubleValue();
double highVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
+ valueDelta, dataArea, yAxisLocation);
double lowVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
- valueDelta, dataArea, yAxisLocation);
if (this.errorIndicatorStroke != null) {
g2.setStroke(this.errorIndicatorStroke);
}
else {
g2.setStroke(getItemOutlineStroke(row, column));
}
if (this.errorIndicatorPaint != null) {
g2.setPaint(this.errorIndicatorPaint);
}
else {
g2.setPaint(getItemOutlinePaint(row, column));
}
Line2D line = null;
line = new Line2D.Double(rectX + rectWidth / 2.0d, lowVal,
rectX + rectWidth / 2.0d, highVal);
g2.draw(line);
line = new Line2D.Double(rectX + rectWidth / 2.0d - 5.0d, highVal,
rectX + rectWidth / 2.0d + 5.0d, highVal);
g2.draw(line);
line = new Line2D.Double(rectX + rectWidth / 2.0d - 5.0d, lowVal,
rectX + rectWidth / 2.0d + 5.0d, lowVal);
g2.draw(line);
CategoryItemLabelGenerator generator = getItemLabelGenerator(row,
column);
if (generator != null && isItemLabelVisible(row, column)) {
drawItemLabel(g2, dataset, row, column, plot, generator, bar,
(value < 0.0));
}
// add an item entity, if this information is being collected
EntityCollection entities = state.getEntityCollection();
if (entities != null) {
addItemEntity(entities, dataset, row, column, bar);
}
}
// Test Case
[/INST]
public void testDrawWithNullMeanVertical() {
boolean success = false;
try {
DefaultStatisticalCategoryDataset dataset
= new DefaultStatisticalCategoryDataset();
dataset.add(1.0, 2.0, "S1", "C1");
dataset.add(null, new Double(4.0), "S1", "C2");
CategoryPlot plot = new CategoryPlot(dataset,
new CategoryAxis("Category"), new NumberAxis("Value"),
new StatisticalBarRenderer());
JFreeChart chart = new JFreeChart(plot);
/* BufferedImage image = */ chart.createBufferedImage(300, 200,
null);
success = true;
}
catch (NullPointerException e) {
e.printStackTrace();
success = false;
}
assertTrue(success);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected AxisState drawLabel(String label, Graphics2D g2,
Rectangle2D plotArea, Rectangle2D dataArea, RectangleEdge edge,
AxisState state, PlotRenderingInfo plotState) {
// it is unlikely that 'state' will be null, but check anyway...
if (state == null) {
throw new IllegalArgumentException("Null 'state' argument.");
}
if ((label == null) || (label.equals(""))) {
return state;
}
Font font = getLabelFont();
RectangleInsets insets = getLabelInsets();
g2.setFont(font);
g2.setPaint(getLabelPaint());
FontMetrics fm = g2.getFontMetrics();
Rectangle2D labelBounds = TextUtilities.getTextBounds(label, g2, fm);
Shape hotspot = null;
if (edge == RectangleEdge.TOP) {
AffineTransform t = AffineTransform.getRotateInstance(
getLabelAngle(), labelBounds.getCenterX(),
labelBounds.getCenterY());
Shape rotatedLabelBounds = t.createTransformedShape(labelBounds);
labelBounds = rotatedLabelBounds.getBounds2D();
float w = (float) labelBounds.getWidth();
float h = (float) labelBounds.getHeight();
float labelx = (float) dataArea.getCenterX();
float labely = (float) (state.getCursor() - insets.getBottom()
- h / 2.0);
TextUtilities.drawRotatedString(label, g2, labelx, labely,
TextAnchor.CENTER, getLabelAngle(), TextAnchor.CENTER);
hotspot = new Rectangle2D.Float(labelx - w / 2.0f,
labely - h / 2.0f, w, h);
state.cursorUp(insets.getTop() + labelBounds.getHeight()
+ insets.getBottom());
}
else if (edge == RectangleEdge.BOTTOM) {
AffineTransform t = AffineTransform.getRotateInstance(
getLabelAngle(), labelBounds.getCenterX(),
labelBounds.getCenterY());
Shape rotatedLabelBounds = t.createTransformedShape(labelBounds);
labelBounds = rotatedLabelBounds.getBounds2D();
float w = (float) labelBounds.getWidth();
float h = (float) labelBounds.getHeight();
float labelx = (float) dataArea.getCenterX();
float labely = (float) (state.getCursor() + insets.getTop()
+ h / 2.0);
TextUtilities.drawRotatedString(label, g2, labelx, labely,
TextAnchor.CENTER, getLabelAngle(), TextAnchor.CENTER);
hotspot = new Rectangle2D.Float(labelx - w / 2.0f,
labely - h / 2.0f, w, h);
state.cursorDown(insets.getTop() + labelBounds.getHeight()
+ insets.getBottom());
}
else if (edge == RectangleEdge.LEFT) {
AffineTransform t = AffineTransform.getRotateInstance(
getLabelAngle() - Math.PI / 2.0, labelBounds.getCenterX(),
labelBounds.getCenterY());
Shape rotatedLabelBounds = t.createTransformedShape(labelBounds);
labelBounds = rotatedLabelBounds.getBounds2D();
float w = (float) labelBounds.getWidth();
float h = (float) labelBounds.getHeight();
float labelx = (float) (state.getCursor() - insets.getRight()
- w / 2.0);
float labely = (float) dataArea.getCenterY();
TextUtilities.drawRotatedString(label, g2, labelx, labely,
TextAnchor.CENTER, getLabelAngle() - Math.PI / 2.0,
TextAnchor.CENTER);
hotspot = new Rectangle2D.Float(labelx - w / 2.0f,
labely - h / 2.0f, w, h);
state.cursorLeft(insets.getLeft() + labelBounds.getWidth()
+ insets.getRight());
}
else if (edge == RectangleEdge.RIGHT) {
AffineTransform t = AffineTransform.getRotateInstance(
getLabelAngle() + Math.PI / 2.0,
labelBounds.getCenterX(), labelBounds.getCenterY());
Shape rotatedLabelBounds = t.createTransformedShape(labelBounds);
labelBounds = rotatedLabelBounds.getBounds2D();
float w = (float) labelBounds.getWidth();
float h = (float) labelBounds.getHeight();
float labelx = (float) (state.getCursor()
+ insets.getLeft() + w / 2.0);
float labely = (float) (dataArea.getY() + dataArea.getHeight()
/ 2.0);
TextUtilities.drawRotatedString(label, g2, labelx, labely,
TextAnchor.CENTER, getLabelAngle() + Math.PI / 2.0,
TextAnchor.CENTER);
hotspot = new Rectangle2D.Float(labelx - w / 2.0f,
labely - h / 2.0f, w, h);
state.cursorRight(insets.getLeft() + labelBounds.getWidth()
+ insets.getRight());
}
if (plotState != null && hotspot != null) {
ChartRenderingInfo owner = plotState.getOwner();
EntityCollection entities = owner.getEntityCollection();
if (entities != null) {
entities.add(new AxisLabelEntity(this, hotspot,
this.labelToolTip, this.labelURL));
}
}
return state;
}
// Test Case
[/INST]
public void testDrawWithNullInfo() {
boolean success = false;
try {
BufferedImage image = new BufferedImage(200 , 100,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
this.chart.draw(g2, new Rectangle2D.Double(0, 0, 200, 100), null,
null);
g2.dispose();
success = true;
}
catch (Exception e) {
success = false;
}
assertTrue(success);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public TimeSeries createCopy(int start, int end)
throws CloneNotSupportedException {
if (start < 0) {
throw new IllegalArgumentException("Requires start >= 0.");
}
if (end < start) {
throw new IllegalArgumentException("Requires start <= end.");
}
TimeSeries copy = (TimeSeries) super.clone();
copy.data = new java.util.ArrayList();
if (this.data.size() > 0) {
for (int index = start; index <= end; index++) {
TimeSeriesDataItem item
= (TimeSeriesDataItem) this.data.get(index);
TimeSeriesDataItem clone = (TimeSeriesDataItem) item.clone();
try {
copy.add(clone);
}
catch (SeriesException e) {
e.printStackTrace();
}
}
}
return copy;
}
// Test Case
[/INST]
public void testCreateCopy3() throws CloneNotSupportedException {
TimeSeries s1 = new TimeSeries("S1");
s1.add(new Year(2009), 100.0);
s1.add(new Year(2010), 101.0);
s1.add(new Year(2011), 102.0);
assertEquals(100.0, s1.getMinY(), EPSILON);
assertEquals(102.0, s1.getMaxY(), EPSILON);
TimeSeries s2 = s1.createCopy(0, 1);
assertEquals(100.0, s2.getMinY(), EPSILON);
assertEquals(101.0, s2.getMaxY(), EPSILON);
TimeSeries s3 = s1.createCopy(1, 2);
assertEquals(101.0, s3.getMinY(), EPSILON);
assertEquals(102.0, s3.getMaxY(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Range getDataRange(ValueAxis axis) {
Range result = null;
List mappedDatasets = new ArrayList();
List includedAnnotations = new ArrayList();
boolean isDomainAxis = true;
// is it a domain axis?
int domainIndex = getDomainAxisIndex(axis);
if (domainIndex >= 0) {
isDomainAxis = true;
mappedDatasets.addAll(getDatasetsMappedToDomainAxis(
new Integer(domainIndex)));
if (domainIndex == 0) {
// grab the plot's annotations
Iterator iterator = this.annotations.iterator();
while (iterator.hasNext()) {
XYAnnotation annotation = (XYAnnotation) iterator.next();
if (annotation instanceof XYAnnotationBoundsInfo) {
includedAnnotations.add(annotation);
}
}
}
}
// or is it a range axis?
int rangeIndex = getRangeAxisIndex(axis);
if (rangeIndex >= 0) {
isDomainAxis = false;
mappedDatasets.addAll(getDatasetsMappedToRangeAxis(
new Integer(rangeIndex)));
if (rangeIndex == 0) {
Iterator iterator = this.annotations.iterator();
while (iterator.hasNext()) {
XYAnnotation annotation = (XYAnnotation) iterator.next();
if (annotation instanceof XYAnnotationBoundsInfo) {
includedAnnotations.add(annotation);
}
}
}
}
// iterate through the datasets that map to the axis and get the union
// of the ranges.
Iterator iterator = mappedDatasets.iterator();
while (iterator.hasNext()) {
XYDataset d = (XYDataset) iterator.next();
if (d != null) {
XYItemRenderer r = getRendererForDataset(d);
if (isDomainAxis) {
if (r != null) {
result = Range.combine(result, r.findDomainBounds(d));
}
else {
result = Range.combine(result,
DatasetUtilities.findDomainBounds(d));
}
}
else {
if (r != null) {
result = Range.combine(result, r.findRangeBounds(d));
}
else {
result = Range.combine(result,
DatasetUtilities.findRangeBounds(d));
}
}
Collection c = r.getAnnotations();
Iterator i = c.iterator();
while (i.hasNext()) {
XYAnnotation a = (XYAnnotation) i.next();
if (a instanceof XYAnnotationBoundsInfo) {
includedAnnotations.add(a);
}
}
}
}
Iterator it = includedAnnotations.iterator();
while (it.hasNext()) {
XYAnnotationBoundsInfo xyabi = (XYAnnotationBoundsInfo) it.next();
if (xyabi.getIncludeInDataBounds()) {
if (isDomainAxis) {
result = Range.combine(result, xyabi.getXRange());
}
else {
result = Range.combine(result, xyabi.getYRange());
}
}
}
return result;
}
// Test Case
[/INST]
public void testXYAutoRange1() {
XYSeries series = new XYSeries("Series 1");
series.add(1.0, 1.0);
series.add(2.0, 2.0);
series.add(3.0, 3.0);
XYSeriesCollection dataset = new XYSeriesCollection();
dataset.addSeries(series);
JFreeChart chart = ChartFactory.createScatterPlot(
"Test",
"X",
"Y",
dataset,
PlotOrientation.VERTICAL,
false,
false,
false
);
XYPlot plot = (XYPlot) chart.getPlot();
LogAxis axis = new LogAxis("Log(Y)");
plot.setRangeAxis(axis);
assertEquals(0.9465508226401592, axis.getLowerBound(), EPSILON);
assertEquals(3.1694019256486126, axis.getUpperBound(), EPSILON);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public XYDataItem addOrUpdate(Number x, Number y) {
if (x == null) {
throw new IllegalArgumentException("Null 'x' argument.");
}
// if we get to here, we know that duplicate X values are not permitted
XYDataItem overwritten = null;
int index = indexOf(x);
if (index >= 0 && !this.allowDuplicateXValues) {
XYDataItem existing = (XYDataItem) this.data.get(index);
try {
overwritten = (XYDataItem) existing.clone();
}
catch (CloneNotSupportedException e) {
throw new SeriesException("Couldn't clone XYDataItem!");
}
existing.setY(y);
}
else {
// if the series is sorted, the negative index is a result from
// Collections.binarySearch() and tells us where to insert the
// new item...otherwise it will be just -1 and we should just
// append the value to the list...
if (this.autoSort) {
this.data.add(-index - 1, new XYDataItem(x, y));
}
else {
this.data.add(new XYDataItem(x, y));
}
// check if this addition will exceed the maximum item count...
if (getItemCount() > this.maximumItemCount) {
this.data.remove(0);
}
}
fireSeriesChanged();
return overwritten;
}
// Test Case
[/INST]
public void testBug1955483() {
XYSeries series = new XYSeries("Series", true, true);
series.addOrUpdate(1.0, 1.0);
series.addOrUpdate(1.0, 2.0);
assertEquals(new Double(1.0), series.getY(0));
assertEquals(new Double(2.0), series.getY(1));
assertEquals(2, series.getItemCount());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof ShapeList)) {
return false;
}
return super.equals(obj);
}
// Test Case
[/INST]
public void testSerialization() {
ShapeList l1 = new ShapeList();
l1.setShape(0, new Rectangle(1, 2, 3, 4));
l1.setShape(1, new Line2D.Double(1.0, 2.0, 3.0, 4.0));
l1.setShape(2, null);
ShapeList l2 = null;
try {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
ObjectOutput out = new ObjectOutputStream(buffer);
out.writeObject(l1);
out.close();
ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(
buffer.toByteArray()));
l2 = (ShapeList) in.readObject();
in.close();
}
catch (Exception e) {
e.printStackTrace();
}
assertEquals(l1, l2);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void updateBounds(TimePeriod period, int index) {
long start = period.getStart().getTime();
long end = period.getEnd().getTime();
long middle = start + ((end - start) / 2);
if (this.minStartIndex >= 0) {
long minStart = getDataItem(this.minStartIndex).getPeriod()
.getStart().getTime();
if (start < minStart) {
this.minStartIndex = index;
}
}
else {
this.minStartIndex = index;
}
if (this.maxStartIndex >= 0) {
long maxStart = getDataItem(this.maxStartIndex).getPeriod()
.getStart().getTime();
if (start > maxStart) {
this.maxStartIndex = index;
}
}
else {
this.maxStartIndex = index;
}
if (this.minMiddleIndex >= 0) {
long s = getDataItem(this.minMiddleIndex).getPeriod().getStart()
.getTime();
long e = getDataItem(this.minMiddleIndex).getPeriod().getEnd()
.getTime();
long minMiddle = s + (e - s) / 2;
if (middle < minMiddle) {
this.minMiddleIndex = index;
}
}
else {
this.minMiddleIndex = index;
}
if (this.maxMiddleIndex >= 0) {
long s = getDataItem(this.minMiddleIndex).getPeriod().getStart()
.getTime();
long e = getDataItem(this.minMiddleIndex).getPeriod().getEnd()
.getTime();
long maxMiddle = s + (e - s) / 2;
if (middle > maxMiddle) {
this.maxMiddleIndex = index;
}
}
else {
this.maxMiddleIndex = index;
}
if (this.minEndIndex >= 0) {
long minEnd = getDataItem(this.minEndIndex).getPeriod().getEnd()
.getTime();
if (end < minEnd) {
this.minEndIndex = index;
}
}
else {
this.minEndIndex = index;
}
if (this.maxEndIndex >= 0) {
long maxEnd = getDataItem(this.maxEndIndex).getPeriod().getEnd()
.getTime();
if (end > maxEnd) {
this.maxEndIndex = index;
}
}
else {
this.maxEndIndex = index;
}
}
// Test Case
[/INST]
public void testGetMaxMiddleIndex() {
TimePeriodValues s = new TimePeriodValues("Test");
assertEquals(-1, s.getMaxMiddleIndex());
s.add(new SimpleTimePeriod(100L, 200L), 1.0);
assertEquals(0, s.getMaxMiddleIndex());
s.add(new SimpleTimePeriod(300L, 400L), 2.0);
assertEquals(1, s.getMaxMiddleIndex());
s.add(new SimpleTimePeriod(0L, 50L), 3.0);
assertEquals(1, s.getMaxMiddleIndex());
s.add(new SimpleTimePeriod(150L, 200L), 4.0);
assertEquals(1, s.getMaxMiddleIndex());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Week(Date time, TimeZone zone) {
// defer argument checking...
this(time, RegularTimePeriod.DEFAULT_TIME_ZONE, Locale.getDefault());
}
// Test Case
[/INST]
public void testConstructor() {
Locale savedLocale = Locale.getDefault();
TimeZone savedZone = TimeZone.getDefault();
Locale.setDefault(new Locale("da", "DK"));
TimeZone.setDefault(TimeZone.getTimeZone("Europe/Copenhagen"));
GregorianCalendar cal = (GregorianCalendar) Calendar.getInstance(
TimeZone.getDefault(), Locale.getDefault());
// first day of week is monday
assertEquals(Calendar.MONDAY, cal.getFirstDayOfWeek());
cal.set(2007, Calendar.AUGUST, 26, 1, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
Date t = cal.getTime();
Week w = new Week(t, TimeZone.getTimeZone("Europe/Copenhagen"));
assertEquals(34, w.getWeek());
Locale.setDefault(Locale.US);
TimeZone.setDefault(TimeZone.getTimeZone("US/Detroit"));
cal = (GregorianCalendar) Calendar.getInstance(TimeZone.getDefault());
// first day of week is Sunday
assertEquals(Calendar.SUNDAY, cal.getFirstDayOfWeek());
cal.set(2007, Calendar.AUGUST, 26, 1, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
t = cal.getTime();
w = new Week(t, TimeZone.getTimeZone("Europe/Copenhagen"));
assertEquals(35, w.getWeek());
w = new Week(t, TimeZone.getTimeZone("Europe/Copenhagen"),
new Locale("da", "DK"));
assertEquals(34, w.getWeek());
Locale.setDefault(savedLocale);
TimeZone.setDefault(savedZone);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public TimeSeries createCopy(RegularTimePeriod start, RegularTimePeriod end)
throws CloneNotSupportedException {
if (start == null) {
throw new IllegalArgumentException("Null 'start' argument.");
}
if (end == null) {
throw new IllegalArgumentException("Null 'end' argument.");
}
if (start.compareTo(end) > 0) {
throw new IllegalArgumentException(
"Requires start on or before end.");
}
boolean emptyRange = false;
int startIndex = getIndex(start);
if (startIndex < 0) {
startIndex = -(startIndex + 1);
if (startIndex == this.data.size()) {
emptyRange = true; // start is after last data item
}
}
int endIndex = getIndex(end);
if (endIndex < 0) { // end period is not in original series
endIndex = -(endIndex + 1); // this is first item AFTER end period
endIndex = endIndex - 1; // so this is last item BEFORE end
}
if (endIndex < 0) {
emptyRange = true;
}
if (emptyRange) {
TimeSeries copy = (TimeSeries) super.clone();
copy.data = new java.util.ArrayList();
return copy;
}
else {
return createCopy(startIndex, endIndex);
}
}
// Test Case
[/INST]
public void testBug1864222() {
TimeSeries s = new TimeSeries("S");
s.add(new Day(19, 8, 2005), 1);
s.add(new Day(31, 1, 2006), 1);
boolean pass = true;
try {
s.createCopy(new Day(1, 12, 2005), new Day(18, 1, 2006));
}
catch (CloneNotSupportedException e) {
pass = false;
}
assertTrue(pass);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean hasOption(String opt)
{
return options.containsKey(opt);
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Object getOptionObject(String opt)
{
String res = getOptionValue(opt);
if (!options.containsKey(opt))
{
return null;
}
Object type = ((Option) options.get(opt)).getType();
return (res == null) ? null : TypeHandler.createValue(res, type);
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public String[] getOptionValues(String opt)
{
opt = Util.stripLeadingHyphens(opt);
String key = opt;
if (names.containsKey(opt))
{
key = (String) names.get(opt);
}
if (options.containsKey(key))
{
return ((Option) options.get(key)).getValues();
}
return null;
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
void addOption(Option opt)
{
hashcodeMap.put(new Integer(opt.hashCode()), opt);
String key = opt.getKey();
if (key == null)
{
key = opt.getLongOpt();
}
else
{
names.put(opt.getLongOpt(), key);
}
options.put(key, opt);
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Iterator iterator()
{
return hashcodeMap.values().iterator();
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public Option[] getOptions()
{
Collection processed = options.values();
// reinitialise array
Option[] optionsArray = new Option[processed.size()];
// return the array
return (Option[]) processed.toArray(optionsArray);
}
// Test Case
[/INST]
public void testCLI13()
throws ParseException
{
final String debugOpt = "debug";
Option debug = OptionBuilder
.withArgName( debugOpt )
.withDescription( "turn on debugging" )
.withLongOpt( debugOpt )
.hasArg()
.create( 'd' );
Options options = new Options();
options.addOption( debug );
CommandLine commandLine = new PosixParser().parse( options, new String[]{"-d", "true"} );
assertEquals("true", commandLine.getOptionValue( debugOpt ));
assertEquals("true", commandLine.getOptionValue( 'd' ));
assertTrue(commandLine.hasOption( 'd'));
assertTrue(commandLine.hasOption( debugOpt));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void setOptions(final Options options) {
this.options = options;
this.requiredOptions = options.getRequiredOptions();
}
// Test Case
[/INST]
public void testReuseOptionsTwice() throws Exception
{
Options opts = new Options();
opts.addOption(OptionBuilder.isRequired().create('v'));
GnuParser parser = new GnuParser();
// first parsing
parser.parse(opts, new String[] { "-v" });
try
{
// second parsing, with the same Options instance and an invalid command line
parser.parse(opts, new String[0]);
fail("MissingOptionException not thrown");
}
catch (MissingOptionException e)
{
// expected
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private static void appendOption(final StringBuffer buff,
final Option option,
final boolean required)
{
if (!required)
{
buff.append("[");
}
if (option.getOpt() != null)
{
buff.append("-").append(option.getOpt());
}
else
{
buff.append("--").append(option.getLongOpt());
}
// if the Option has a value
if (option.hasArg() && (option.getArgName() != null))
{
buff.append(" <").append(option.getArgName()).append(">");
}
// if the Option is not a required option
if (!required)
{
buff.append("]");
}
}
// Test Case
[/INST]
public void testPrintOptionWithEmptyArgNameUsage() {
Option option = new Option("f", true, null);
option.setArgName("");
option.setRequired(true);
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f" + EOL, out.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
{
List tokens = new ArrayList();
boolean eatTheRest = false;
for (int i = 0; i < arguments.length; i++)
{
String arg = arguments[i];
if ("--".equals(arg))
{
eatTheRest = true;
tokens.add("--");
}
else if ("-".equals(arg))
{
tokens.add("-");
}
else if (arg.startsWith("-"))
{
String opt = Util.stripLeadingHyphens(arg);
if (options.hasOption(opt))
{
tokens.add(arg);
}
else
{
if (options.hasOption(arg.substring(0, 2)))
{
// the format is --foo=value or -foo=value
// the format is a special properties option (-Dproperty=value)
tokens.add(arg.substring(0, 2)); // -D
tokens.add(arg.substring(2)); // property=value
}
else
{
eatTheRest = stopAtNonOption;
tokens.add(arg);
}
}
}
else
{
tokens.add(arg);
}
if (eatTheRest)
{
for (i++; i < arguments.length; i++)
{
tokens.add(arguments[i]);
}
}
}
return (String[]) tokens.toArray(new String[tokens.size()]);
}
// Test Case
[/INST]
public void testShortWithEqual() throws Exception
{
String[] args = new String[] { "-f=bar" };
Options options = new Options();
options.addOption(OptionBuilder.withLongOpt("foo").hasArg().create('f'));
Parser parser = new GnuParser();
CommandLine cl = parser.parse(options, args);
assertEquals("bar", cl.getOptionValue("foo"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void processValues(final WriteableCommandLine commandLine,
final ListIterator arguments,
final Option option)
throws OptionException {
// count of arguments processed for this option.
int argumentCount = 0;
while (arguments.hasNext() && (argumentCount < maximum)) {
final String allValuesQuoted = (String) arguments.next();
final String allValues = stripBoundaryQuotes(allValuesQuoted);
// should we ignore things that look like options?
if (allValuesQuoted.equals(consumeRemaining)) {
while (arguments.hasNext() && (argumentCount < maximum)) {
++argumentCount;
commandLine.addValue(option, arguments.next());
}
}
// does it look like an option?
else if (commandLine.looksLikeOption(allValuesQuoted)) {
arguments.previous();
break;
}
// should we split the string up?
else if (subsequentSplit) {
final StringTokenizer values =
new StringTokenizer(allValues, String.valueOf(subsequentSeparator));
arguments.remove();
while (values.hasMoreTokens() && (argumentCount < maximum)) {
++argumentCount;
final String token = values.nextToken();
commandLine.addValue(option, token);
arguments.add(token);
}
if (values.hasMoreTokens()) {
throw new OptionException(option, ResourceConstants.ARGUMENT_UNEXPECTED_VALUE,
values.nextToken());
}
}
// it must be a value as it is
else {
++argumentCount;
commandLine.addValue(option, allValues);
}
}
}
// Test Case
[/INST]
public void testLoopingOptionLookAlike2() {
final ArgumentBuilder abuilder = new ArgumentBuilder();
final GroupBuilder gbuilder = new GroupBuilder();
final Argument inputfile_opt = abuilder.withName("input").withMinimum(1).withMaximum(1).create();
final Argument outputfile_opt = abuilder.withName("output").withMinimum(1).withMaximum(1).create();
final Argument targets = new SourceDestArgument(inputfile_opt, outputfile_opt);
final Group options = gbuilder.withOption(targets).create();
final Parser parser = new Parser();
parser.setGroup(options);
try {
parser.parse(new String[] { "testfile.txt", "testfile.txt", "testfile.txt", "testfile.txt" });
fail("OptionException");
} catch (OptionException e) {
assertEquals("Unexpected testfile.txt while processing ", e.getMessage());
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testLoopingOptionLookAlike2() {
final ArgumentBuilder abuilder = new ArgumentBuilder();
final GroupBuilder gbuilder = new GroupBuilder();
final Argument inputfile_opt = abuilder.withName("input").withMinimum(1).withMaximum(1).create();
final Argument outputfile_opt = abuilder.withName("output").withMinimum(1).withMaximum(1).create();
final Argument targets = new SourceDestArgument(inputfile_opt, outputfile_opt);
final Group options = gbuilder.withOption(targets).create();
final Parser parser = new Parser();
parser.setGroup(options);
try {
parser.parse(new String[] { "testfile.txt", "testfile.txt", "testfile.txt", "testfile.txt" });
fail("OptionException");
} catch (OptionException e) {
assertEquals("Unexpected testfile.txt while processing ", e.getMessage());
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testLoopingOptionLookAlike2() {
final ArgumentBuilder abuilder = new ArgumentBuilder();
final GroupBuilder gbuilder = new GroupBuilder();
final Argument inputfile_opt = abuilder.withName("input").withMinimum(1).withMaximum(1).create();
final Argument outputfile_opt = abuilder.withName("output").withMinimum(1).withMaximum(1).create();
final Argument targets = new SourceDestArgument(inputfile_opt, outputfile_opt);
final Group options = gbuilder.withOption(targets).create();
final Parser parser = new Parser();
parser.setGroup(options);
try {
parser.parse(new String[] { "testfile.txt", "testfile.txt", "testfile.txt", "testfile.txt" });
fail("OptionException");
} catch (OptionException e) {
assertEquals("Unexpected testfile.txt while processing ", e.getMessage());
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void validate(final WriteableCommandLine commandLine)
throws OptionException {
// number of options found
int present = 0;
// reference to first unexpected option
Option unexpected = null;
for (final Iterator i = options.iterator(); i.hasNext();) {
final Option option = (Option) i.next();
// needs validation?
boolean validate = option.isRequired() || option instanceof Group;
if (validate) {
option.validate(commandLine);
}
// if the child option is present then validate it
if (commandLine.hasOption(option)) {
if (++present > maximum) {
unexpected = option;
break;
}
option.validate(commandLine);
}
}
// too many options
if (unexpected != null) {
throw new OptionException(this, ResourceConstants.UNEXPECTED_TOKEN,
unexpected.getPreferredName());
}
// too few option
if (present < minimum) {
throw new OptionException(this, ResourceConstants.MISSING_OPTION);
}
// validate each anonymous argument
for (final Iterator i = anonymous.iterator(); i.hasNext();) {
final Option option = (Option) i.next();
option.validate(commandLine);
}
}
// Test Case
[/INST]
public void testFileValidator() {
final DefaultOptionBuilder obuilder = new DefaultOptionBuilder();
final ArgumentBuilder abuilder = new ArgumentBuilder();
final GroupBuilder gbuilder = new GroupBuilder();
DefaultOption fileNameOption = obuilder.withShortName("f")
.withLongName("file-name").withRequired(true).withDescription(
"name of an existing file").withArgument(
abuilder.withName("file-name").withValidator(
FileValidator.getExistingFileInstance())
.create()).create();
Group options = gbuilder.withName("options").withOption(fileNameOption)
.create();
Parser parser = new Parser();
parser.setHelpTrigger("--help");
parser.setGroup(options);
final String fileName = "src/test/org/apache/commons/cli2/bug/BugCLI144Test.java";
CommandLine cl = parser
.parseAndHelp(new String[] { "--file-name", fileName });
assertNotNull(cl);
assertEquals("Wrong file", new File(fileName), cl.getValue(fileNameOption));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public List getValues(final Option option,
List defaultValues) {
// initialize the return list
List valueList = (List) values.get(option);
// grab the correct default values
if ((valueList == null) || valueList.isEmpty()) {
valueList = defaultValues;
}
// augment the list with the default values
if ((valueList == null) || valueList.isEmpty()) {
valueList = (List) this.defaultValues.get(option);
}
// if there are more default values as specified, add them to
// the list.
// copy the list first
return valueList == null ? Collections.EMPTY_LIST : valueList;
}
// Test Case
[/INST]
public void testSingleOptionSingleArgument() throws Exception {
Parser parser = createDefaultValueParser(new String[]{"100", "1000"});
String enteredValue1 = "1";
String[] args = new String[]{"-b", enteredValue1};
CommandLine cl = parser.parse(args);
CommandLine cmd = cl;
assertNotNull(cmd);
List b = cmd.getValues("-b");
assertEquals("[" + enteredValue1 + ", 1000]", b + "");
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public GroupImpl(final List options,
final String name,
final String description,
final int minimum,
final int maximum) {
super(0, false);
this.name = name;
this.description = description;
this.minimum = minimum;
this.maximum = maximum;
// store a copy of the options to be used by the
// help methods
this.options = Collections.unmodifiableList(options);
// anonymous Argument temporary storage
final List newAnonymous = new ArrayList();
// map (key=trigger & value=Option) temporary storage
final SortedMap newOptionMap = new TreeMap(ReverseStringComparator.getInstance());
// prefixes temporary storage
final Set newPrefixes = new HashSet();
// process the options
for (final Iterator i = options.iterator(); i.hasNext();) {
final Option option = (Option) i.next();
if (option instanceof Argument) {
i.remove();
newAnonymous.add(option);
} else {
final Set triggers = option.getTriggers();
for (Iterator j = triggers.iterator(); j.hasNext();) {
newOptionMap.put(j.next(), option);
}
// store the prefixes
newPrefixes.addAll(option.getPrefixes());
}
}
this.anonymous = Collections.unmodifiableList(newAnonymous);
this.optionMap = Collections.unmodifiableSortedMap(newOptionMap);
this.prefixes = Collections.unmodifiableSet(newPrefixes);
}
// Test Case
[/INST]
public void testMultipleChildOptions() throws OptionException {
CommandLine cl = parser.parse(new String[] { "--child", "test",
"--sub", "anotherTest" });
assertTrue("Child option not found", cl.hasOption(childOption1));
assertEquals("Wrong value for option", "test", cl
.getValue(childOption1));
assertTrue("Sub option not found", cl.hasOption(childOption2));
assertEquals("Wrong value for sub option", "anotherTest", cl
.getValue(childOption2));
assertTrue("Child group not found", cl.hasOption(childGroup));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void addOption(Option option) {
options.add(option);
nameToOption.put(option.getPreferredName(), option);
for (Iterator i = option.getTriggers().iterator(); i.hasNext();) {
nameToOption.put(i.next(), option);
}
// ensure that all parent options are also added
}
// Test Case
[/INST]
public void testMultipleChildOptions() throws OptionException {
CommandLine cl = parser.parse(new String[] { "--child", "test",
"--sub", "anotherTest" });
assertTrue("Child option not found", cl.hasOption(childOption1));
assertEquals("Wrong value for option", "test", cl
.getValue(childOption1));
assertTrue("Sub option not found", cl.hasOption(childOption2));
assertEquals("Wrong value for sub option", "anotherTest", cl
.getValue(childOption2));
assertTrue("Child group not found", cl.hasOption(childGroup));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testMultipleChildOptions() throws OptionException {
CommandLine cl = parser.parse(new String[] { "--child", "test",
"--sub", "anotherTest" });
assertTrue("Child option not found", cl.hasOption(childOption1));
assertEquals("Wrong value for option", "test", cl
.getValue(childOption1));
assertTrue("Sub option not found", cl.hasOption(childOption2));
assertEquals("Wrong value for sub option", "anotherTest", cl
.getValue(childOption2));
assertTrue("Child group not found", cl.hasOption(childGroup));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testMultipleChildOptions() throws OptionException {
CommandLine cl = parser.parse(new String[] { "--child", "test",
"--sub", "anotherTest" });
assertTrue("Child option not found", cl.hasOption(childOption1));
assertEquals("Wrong value for option", "test", cl
.getValue(childOption1));
assertTrue("Sub option not found", cl.hasOption(childOption2));
assertEquals("Wrong value for sub option", "anotherTest", cl
.getValue(childOption2));
assertTrue("Child group not found", cl.hasOption(childGroup));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void burstToken(String token, boolean stopAtNonOption)
{
for (int i = 1; i < token.length(); i++)
{
String ch = String.valueOf(token.charAt(i));
if (options.hasOption(ch))
{
tokens.add("-" + ch);
currentOption = options.getOption(ch);
if (currentOption.hasArg() && (token.length() != (i + 1)))
{
tokens.add(token.substring(i + 1));
break;
}
}
else if (stopAtNonOption)
{
process(token.substring(i));
}
else
{
tokens.add(token);
break;
}
}
}
// Test Case
[/INST]
public void testStopBursting() throws Exception
{
String[] args = new String[] { "-azc" };
CommandLine cl = parser.parse(options, args, true);
assertTrue( "Confirm -a is set", cl.hasOption("a") );
assertFalse( "Confirm -c is not set", cl.hasOption("c") );
assertTrue( "Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
assertTrue(cl.getArgList().contains("zc"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
{
init();
this.options = options;
// an iterator for the command line tokens
Iterator iter = Arrays.asList(arguments).iterator();
// process each command line token
while (iter.hasNext())
{
// get the next command line token
String token = (String) iter.next();
// handle SPECIAL TOKEN
if (token.startsWith("--"))
{
if (token.indexOf('=') != -1)
{
tokens.add(token.substring(0, token.indexOf('=')));
tokens.add(token.substring(token.indexOf('=') + 1, token.length()));
}
else
{
tokens.add(token);
}
}
// single hyphen
else if ("-".equals(token))
{
processSingleHyphen(token);
}
else if (token.startsWith("-"))
{
if (token.length() == 2)
{
processOptionToken(token, stopAtNonOption);
}
else if (options.hasOption(token))
{
tokens.add(token);
}
// requires bursting
else
{
burstToken(token, stopAtNonOption);
}
}
else if (stopAtNonOption)
{
process(token);
}
else
{
tokens.add(token);
}
gobble(iter);
}
return (String[]) tokens.toArray(new String[tokens.size()]);
}
// Test Case
[/INST]
public void testStop2() throws Exception
{
String[] args = new String[]{"-z",
"-a",
"-btoast"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void processSingleHyphen(String hyphen)
{
tokens.add(hyphen);
}
// Test Case
[/INST]
public void testStop2() throws Exception
{
String[] args = new String[]{"-z",
"-a",
"-btoast"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void processOptionToken(String token, boolean stopAtNonOption)
{
if (options.hasOption(token))
{
currentOption = options.getOption(token);
tokens.add(token);
}
else if (stopAtNonOption)
{
eatTheRest = true;
}
}
// Test Case
[/INST]
public void testStop2() throws Exception
{
String[] args = new String[]{"-z",
"-a",
"-btoast"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void processOptionToken(String token, boolean stopAtNonOption)
{
if (options.hasOption(token))
{
currentOption = options.getOption(token);
tokens.add(token);
}
else if (stopAtNonOption)
{
eatTheRest = true;
tokens.add(token);
}
}
// Test Case
[/INST]
public void testUnrecognizedOption2() throws Exception
{
String[] args = new String[] { "-z", "-abtoast", "foo", "bar" };
try
{
parser.parse(options, args);
fail("UnrecognizedOptionException wasn't thrown");
}
catch (UnrecognizedOptionException e)
{
assertEquals("-z", e.getOption());
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void burstToken(String token, boolean stopAtNonOption)
{
int tokenLength = token.length();
for (int i = 1; i < tokenLength; i++)
{
String ch = String.valueOf(token.charAt(i));
boolean hasOption = options.hasOption(ch);
if (hasOption)
{
tokens.add("-" + ch);
currentOption = options.getOption(ch);
if (currentOption.hasArg() && (token.length() != (i + 1)))
{
tokens.add(token.substring(i + 1));
break;
}
}
else if (stopAtNonOption)
{
process(token.substring(i));
}
else
{
tokens.add("-" + ch);
}
}
}
// Test Case
[/INST]
public void test() throws Exception
{
Options options = buildCommandLineOptions();
CommandLineParser parser = new PosixParser();
String[] args = new String[] {"-t", "-something" };
CommandLine commandLine;
commandLine = parser.parse( options, args );
assertEquals("-something", commandLine.getOptionValue( 't'));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
{
init();
this.options = options;
// an iterator for the command line tokens
Iterator iter = Arrays.asList(arguments).iterator();
// process each command line token
while (iter.hasNext())
{
// get the next command line token
String token = (String) iter.next();
// handle long option --foo or --foo=bar
if (token.startsWith("--"))
{
if (token.indexOf('=') != -1)
{
tokens.add(token.substring(0, token.indexOf('=')));
tokens.add(token.substring(token.indexOf('=') + 1, token.length()));
}
else
{
tokens.add(token);
}
}
// single hyphen
else if ("-".equals(token))
{
tokens.add(token);
}
else if (token.startsWith("-"))
{
if (token.length() == 2)
{
processOptionToken(token, stopAtNonOption);
}
else if (options.hasOption(token))
{
tokens.add(token);
}
// requires bursting
else
{
burstToken(token, stopAtNonOption);
}
}
else if (stopAtNonOption)
{
process(token);
}
else
{
tokens.add(token);
}
gobble(iter);
}
return (String[]) tokens.toArray(new String[tokens.size()]);
}
// Test Case
[/INST]
public void testStop3() throws Exception
{
String[] args = new String[]{"--zop==1",
"-abtoast",
"--b=bar"};
CommandLine cl = parser.parse(options, args, true);
assertFalse("Confirm -a is not set", cl.hasOption("a"));
assertFalse("Confirm -b is not set", cl.hasOption("b"));
assertTrue("Confirm 3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public WriteableCommandLineImpl(final Option rootOption,
final List arguments) {
this.prefixes = rootOption.getPrefixes();
this.normalised = arguments;
}
// Test Case
[/INST]
public void testNegativeNumber() throws OptionException
{
final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
final ArgumentBuilder aBuilder = new ArgumentBuilder();
final GroupBuilder gBuilder = new GroupBuilder();
final Argument numArg = aBuilder.withValidator(
NumberValidator.getNumberInstance()).withMinimum(1)
.withMaximum(1).create();
final Option numOpt = oBuilder.withLongName("num").withArgument(numArg)
.create();
final Group options = gBuilder.withOption(numOpt).create();
final Parser parser = new Parser();
parser.setGroup(options);
CommandLine cl = parser.parse(new String[] {
"--num", "-42"
});
Number num = (Number) cl.getValue(numOpt);
assertEquals("Wrong option value", -42, num.intValue());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public boolean looksLikeOption(final String trigger)
{
// this is a reentrant call
for (final Iterator i = prefixes.iterator(); i.hasNext();)
{
final String prefix = (String) i.next();
if (trigger.startsWith(prefix))
{
return true;
}
}
return false;
}
// Test Case
[/INST]
public void testNegativeNumber() throws OptionException
{
final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
final ArgumentBuilder aBuilder = new ArgumentBuilder();
final GroupBuilder gBuilder = new GroupBuilder();
final Argument numArg = aBuilder.withValidator(
NumberValidator.getNumberInstance()).withMinimum(1)
.withMaximum(1).create();
final Option numOpt = oBuilder.withLongName("num").withArgument(numArg)
.create();
final Group options = gBuilder.withOption(numOpt).create();
final Parser parser = new Parser();
parser.setGroup(options);
CommandLine cl = parser.parse(new String[] {
"--num", "-42"
});
Number num = (Number) cl.getValue(numOpt);
assertEquals("Wrong option value", -42, num.intValue());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private boolean looksLikeOption(final WriteableCommandLine commandLine,
final String trigger) {
return commandLine.looksLikeOption(trigger);
}
// Test Case
[/INST]
public void testNegativeNumber() throws OptionException
{
final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
final ArgumentBuilder aBuilder = new ArgumentBuilder();
final GroupBuilder gBuilder = new GroupBuilder();
final Argument numArg = aBuilder.withValidator(
NumberValidator.getNumberInstance()).withMinimum(1)
.withMaximum(1).create();
final Option numOpt = oBuilder.withLongName("num").withArgument(numArg)
.create();
final Group options = gBuilder.withOption(numOpt).create();
final Parser parser = new Parser();
parser.setGroup(options);
CommandLine cl = parser.parse(new String[] {
"--num", "-42"
});
Number num = (Number) cl.getValue(numOpt);
assertEquals("Wrong option value", -42, num.intValue());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testNegativeNumber() throws OptionException
{
final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
final ArgumentBuilder aBuilder = new ArgumentBuilder();
final GroupBuilder gBuilder = new GroupBuilder();
final Argument numArg = aBuilder.withValidator(
NumberValidator.getNumberInstance()).withMinimum(1)
.withMaximum(1).create();
final Option numOpt = oBuilder.withLongName("num").withArgument(numArg)
.create();
final Group options = gBuilder.withOption(numOpt).create();
final Parser parser = new Parser();
parser.setGroup(options);
CommandLine cl = parser.parse(new String[] {
"--num", "-42"
});
Number num = (Number) cl.getValue(numOpt);
assertEquals("Wrong option value", -42, num.intValue());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
{
init();
this.options = options;
// an iterator for the command line tokens
Iterator iter = Arrays.asList(arguments).iterator();
// process each command line token
while (iter.hasNext())
{
// get the next command line token
String token = (String) iter.next();
// handle long option --foo or --foo=bar
if (token.startsWith("--"))
{
int pos = token.indexOf('=');
String opt = pos == -1 ? token : token.substring(0, pos); // --foo
if (!options.hasOption(opt))
{
processNonOptionToken(token);
}
else
{
tokens.add(opt);
if (pos != -1)
{
tokens.add(token.substring(pos + 1));
}
}
}
// single hyphen
else if ("-".equals(token))
{
tokens.add(token);
}
else if (token.startsWith("-"))
{
if (token.length() == 2 || options.hasOption(token))
{
processOptionToken(token, stopAtNonOption);
}
// requires bursting
else
{
burstToken(token, stopAtNonOption);
}
}
else if (stopAtNonOption)
{
processNonOptionToken(token);
}
else
{
tokens.add(token);
}
gobble(iter);
}
return (String[]) tokens.toArray(new String[tokens.size()]);
}
// Test Case
[/INST]
public void testGroovy() throws Exception {
Options options = new Options();
options.addOption(
OptionBuilder.withLongOpt("define").
withDescription("define a system property").
hasArg(true).
withArgName("name=value").
create('D'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("usage information")
.withLongOpt("help")
.create('h'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("debug mode will print out full stack traces")
.withLongOpt("debug")
.create('d'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("display the Groovy and JVM versions")
.withLongOpt("version")
.create('v'));
options.addOption(
OptionBuilder.withArgName("charset")
.hasArg()
.withDescription("specify the encoding of the files")
.withLongOpt("encoding")
.create('c'));
options.addOption(
OptionBuilder.withArgName("script")
.hasArg()
.withDescription("specify a command line script")
.create('e'));
options.addOption(
OptionBuilder.withArgName("extension")
.hasOptionalArg()
.withDescription("modify files in place; create backup if extension is given (e.g. \'.bak\')")
.create('i'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line using implicit 'line' variable")
.create('n'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line and print result (see also -n)")
.create('p'));
options.addOption(
OptionBuilder.withArgName("port")
.hasOptionalArg()
.withDescription("listen on a port and process inbound lines")
.create('l'));
options.addOption(
OptionBuilder.withArgName("splitPattern")
.hasOptionalArg()
.withDescription("split lines using splitPattern (default '\\s') using implicit 'split' variable")
.withLongOpt("autosplit")
.create('a'));
Parser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-e", "println 'hello'" }, true);
assertTrue(line.hasOption('e'));
assertEquals("println 'hello'", line.getOptionValue('e'));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void processNonOptionToken(String value)
{
eatTheRest = true;
tokens.add("--");
tokens.add(value);
}
// Test Case
[/INST]
public void testGroovy() throws Exception {
Options options = new Options();
options.addOption(
OptionBuilder.withLongOpt("define").
withDescription("define a system property").
hasArg(true).
withArgName("name=value").
create('D'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("usage information")
.withLongOpt("help")
.create('h'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("debug mode will print out full stack traces")
.withLongOpt("debug")
.create('d'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("display the Groovy and JVM versions")
.withLongOpt("version")
.create('v'));
options.addOption(
OptionBuilder.withArgName("charset")
.hasArg()
.withDescription("specify the encoding of the files")
.withLongOpt("encoding")
.create('c'));
options.addOption(
OptionBuilder.withArgName("script")
.hasArg()
.withDescription("specify a command line script")
.create('e'));
options.addOption(
OptionBuilder.withArgName("extension")
.hasOptionalArg()
.withDescription("modify files in place; create backup if extension is given (e.g. \'.bak\')")
.create('i'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line using implicit 'line' variable")
.create('n'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line and print result (see also -n)")
.create('p'));
options.addOption(
OptionBuilder.withArgName("port")
.hasOptionalArg()
.withDescription("listen on a port and process inbound lines")
.create('l'));
options.addOption(
OptionBuilder.withArgName("splitPattern")
.hasOptionalArg()
.withDescription("split lines using splitPattern (default '\\s') using implicit 'split' variable")
.withLongOpt("autosplit")
.create('a'));
Parser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-e", "println 'hello'" }, true);
assertTrue(line.hasOption('e'));
assertEquals("println 'hello'", line.getOptionValue('e'));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void processOptionToken(String token, boolean stopAtNonOption)
{
if (stopAtNonOption && !options.hasOption(token))
{
eatTheRest = true;
}
tokens.add(token);
}
// Test Case
[/INST]
public void testGroovy() throws Exception {
Options options = new Options();
options.addOption(
OptionBuilder.withLongOpt("define").
withDescription("define a system property").
hasArg(true).
withArgName("name=value").
create('D'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("usage information")
.withLongOpt("help")
.create('h'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("debug mode will print out full stack traces")
.withLongOpt("debug")
.create('d'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("display the Groovy and JVM versions")
.withLongOpt("version")
.create('v'));
options.addOption(
OptionBuilder.withArgName("charset")
.hasArg()
.withDescription("specify the encoding of the files")
.withLongOpt("encoding")
.create('c'));
options.addOption(
OptionBuilder.withArgName("script")
.hasArg()
.withDescription("specify a command line script")
.create('e'));
options.addOption(
OptionBuilder.withArgName("extension")
.hasOptionalArg()
.withDescription("modify files in place; create backup if extension is given (e.g. \'.bak\')")
.create('i'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line using implicit 'line' variable")
.create('n'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line and print result (see also -n)")
.create('p'));
options.addOption(
OptionBuilder.withArgName("port")
.hasOptionalArg()
.withDescription("listen on a port and process inbound lines")
.create('l'));
options.addOption(
OptionBuilder.withArgName("splitPattern")
.hasOptionalArg()
.withDescription("split lines using splitPattern (default '\\s') using implicit 'split' variable")
.withLongOpt("autosplit")
.create('a'));
Parser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-e", "println 'hello'" }, true);
assertTrue(line.hasOption('e'));
assertEquals("println 'hello'", line.getOptionValue('e'));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void burstToken(String token, boolean stopAtNonOption)
{
Option currentOption;
for (int i = 1; i < token.length(); i++)
{
String ch = String.valueOf(token.charAt(i));
if (options.hasOption(ch))
{
tokens.add("-" + ch);
currentOption = options.getOption(ch);
if (currentOption.hasArg() && (token.length() != (i + 1)))
{
tokens.add(token.substring(i + 1));
break;
}
}
else if (stopAtNonOption)
{
processNonOptionToken(token.substring(i));
break;
}
else
{
tokens.add(token);
break;
}
}
}
// Test Case
[/INST]
public void testGroovy() throws Exception {
Options options = new Options();
options.addOption(
OptionBuilder.withLongOpt("define").
withDescription("define a system property").
hasArg(true).
withArgName("name=value").
create('D'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("usage information")
.withLongOpt("help")
.create('h'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("debug mode will print out full stack traces")
.withLongOpt("debug")
.create('d'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("display the Groovy and JVM versions")
.withLongOpt("version")
.create('v'));
options.addOption(
OptionBuilder.withArgName("charset")
.hasArg()
.withDescription("specify the encoding of the files")
.withLongOpt("encoding")
.create('c'));
options.addOption(
OptionBuilder.withArgName("script")
.hasArg()
.withDescription("specify a command line script")
.create('e'));
options.addOption(
OptionBuilder.withArgName("extension")
.hasOptionalArg()
.withDescription("modify files in place; create backup if extension is given (e.g. \'.bak\')")
.create('i'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line using implicit 'line' variable")
.create('n'));
options.addOption(
OptionBuilder.hasArg(false)
.withDescription("process files line by line and print result (see also -n)")
.create('p'));
options.addOption(
OptionBuilder.withArgName("port")
.hasOptionalArg()
.withDescription("listen on a port and process inbound lines")
.create('l'));
options.addOption(
OptionBuilder.withArgName("splitPattern")
.hasOptionalArg()
.withDescription("split lines using splitPattern (default '\\s') using implicit 'split' variable")
.withLongOpt("autosplit")
.create('a'));
Parser parser = new PosixParser();
CommandLine line = parser.parse(options, new String[] { "-e", "println 'hello'" }, true);
assertTrue(line.hasOption('e'));
assertEquals("println 'hello'", line.getOptionValue('e'));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected StringBuffer renderWrappedText(StringBuffer sb, int width,
int nextLineTabStop, String text)
{
int pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(rtrim(text));
return sb;
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
// all following lines must be padded with nextLineTabStop space
// characters
final String padding = createPadding(nextLineTabStop);
while (true)
{
int lastPos = pos;
text = padding + text.substring(pos).trim();
pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(text);
return sb;
} else
if (pos == lastPos)
{
throw new RuntimeException("Text too long for line - throwing exception to avoid infinite loop [CLI-162]: " + text);
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
}
}
// Test Case
[/INST]
public void testInfiniteLoop() {
HelpFormatter formatter = new HelpFormatter();
formatter.setWidth(20);
formatter.printHelp("app", options); // used to hang & crash
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected StringBuffer renderWrappedText(StringBuffer sb, int width,
int nextLineTabStop, String text)
{
int pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(rtrim(text));
return sb;
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
if (nextLineTabStop >= width)
{
// stops infinite loop happening
throw new IllegalStateException("Total width is less than the width of the argument and indent " +
"- no room for the description");
}
// all following lines must be padded with nextLineTabStop space
// characters
final String padding = createPadding(nextLineTabStop);
while (true)
{
text = padding + text.substring(pos).trim();
pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(text);
return sb;
}
if ( (text.length() > width) && (pos == nextLineTabStop - 1) )
{
pos = width;
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
}
}
// Test Case
[/INST]
public void testLongLineChunkingIndentIgnored() throws ParseException, IOException {
Options options = new Options();
options.addOption("x", "extralongarg", false, "This description is Long." );
HelpFormatter formatter = new HelpFormatter();
StringWriter sw = new StringWriter();
formatter.printHelp(new PrintWriter(sw), 22, this.getClass().getName(), "Header", options, 0, 5, "Footer");
String expected = "usage:\n" +
" org.apache.comm\n" +
" ons.cli.bug.Bug\n" +
" CLI162Test\n" +
"Header\n" +
"-x,--extralongarg\n" +
" T\n" +
" h\n" +
" i\n" +
" s\n" +
" d\n" +
" e\n" +
" s\n" +
" c\n" +
" r\n" +
" i\n" +
" p\n" +
" t\n" +
" i\n" +
" o\n" +
" n\n" +
" i\n" +
" s\n" +
" L\n" +
" o\n" +
" n\n" +
" g\n" +
" .\n" +
"Footer\n";
assertEquals( "Long arguments did not split as expected", expected, sw.toString() );
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected StringBuffer renderWrappedText(StringBuffer sb, int width,
int nextLineTabStop, String text)
{
int pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(rtrim(text));
return sb;
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
if (nextLineTabStop >= width)
{
// stops infinite loop happening
nextLineTabStop = width - 1;
}
// all following lines must be padded with nextLineTabStop space
// characters
final String padding = createPadding(nextLineTabStop);
while (true)
{
text = padding + text.substring(pos).trim();
pos = findWrapPos(text, width, 0);
if (pos == -1)
{
sb.append(text);
return sb;
}
if ( (text.length() > width) && (pos == nextLineTabStop - 1) )
{
pos = width;
}
sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
}
}
// Test Case
[/INST]
public void testLongLineChunkingIndentIgnored() throws ParseException, IOException {
Options options = new Options();
options.addOption("x", "extralongarg", false, "This description is Long." );
HelpFormatter formatter = new HelpFormatter();
StringWriter sw = new StringWriter();
formatter.printHelp(new PrintWriter(sw), 22, this.getClass().getName(), "Header", options, 0, 5, "Footer");
System.err.println(sw.toString());
String expected = "usage:\n" +
" org.apache.comm\n" +
" ons.cli.bug.Bug\n" +
" CLI162Test\n" +
"Header\n" +
"-x,--extralongarg\n" +
" This description is\n" +
" Long.\n" +
"Footer\n";
assertEquals( "Long arguments did not split as expected", expected, sw.toString() );
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public static Option create(String opt) throws IllegalArgumentException
{
// create the option
Option option = new Option(opt, description);
// set the option properties
option.setLongOpt(longopt);
option.setRequired(required);
option.setOptionalArg(optionalArg);
option.setArgs(numberOfArgs);
option.setType(type);
option.setValueSeparator(valuesep);
option.setArgName(argName);
// reset the OptionBuilder properties
OptionBuilder.reset();
// return the Option instance
return option;
}
// Test Case
[/INST]
public void testBuilderIsResettedAlways() {
try
{
OptionBuilder.withDescription("JUnit").create('"');
fail("IllegalArgumentException expected");
}
catch (IllegalArgumentException e)
{
// expected
}
assertNull("we inherited a description", OptionBuilder.create('x').getDescription());
try
{
OptionBuilder.withDescription("JUnit").create();
fail("IllegalArgumentException expected");
}
catch (IllegalArgumentException e)
{
// expected
}
assertNull("we inherited a description", OptionBuilder.create('x').getDescription());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void setSelected(Option option) throws AlreadySelectedException
{
if (option == null)
{
// reset the option previously selected
selected = null;
return;
}
// if no option has already been selected or the
// same option is being reselected then set the
// selected member variable
if (selected == null || selected.equals(option.getOpt()))
{
selected = option.getOpt();
}
else
{
throw new AlreadySelectedException(this, option);
}
}
// Test Case
[/INST]
public void testOptionGroupLong() throws Exception
{
OptionGroup group = new OptionGroup();
group.addOption(OptionBuilder.withLongOpt("foo").create());
group.addOption(OptionBuilder.withLongOpt("bar").create());
Options options = new Options();
options.addOptionGroup(group);
CommandLine cl = parser.parse(options, new String[] { "--bar" });
assertTrue(cl.hasOption("bar"));
assertEquals("selected option", "bar", group.getSelected());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void processProperties(Properties properties)
{
if (properties == null)
{
return;
}
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String option = e.nextElement().toString();
if (!cmd.hasOption(option))
{
Option opt = getOptions().getOption(option);
// get the value from the properties instance
String value = properties.getProperty(option);
if (opt.hasArg())
{
if (opt.getValues() == null || opt.getValues().length == 0)
{
try
{
opt.addValueForProcessing(value);
}
catch (RuntimeException exp)
{
// if we cannot add the value don't worry about it
}
}
}
else if (!("yes".equalsIgnoreCase(value)
|| "true".equalsIgnoreCase(value)
|| "1".equalsIgnoreCase(value)))
{
// if the value is not yes, true or 1 then don't add the
// option to the CommandLine
break;
}
cmd.addOption(opt);
}
}
}
// Test Case
[/INST]
public void testPropertyOptionFlags() throws Exception
{
Properties properties = new Properties();
properties.setProperty( "a", "true" );
properties.setProperty( "c", "yes" );
properties.setProperty( "e", "1" );
Parser parser = new PosixParser();
CommandLine cmd = parser.parse(opts, null, properties);
assertTrue( cmd.hasOption("a") );
assertTrue( cmd.hasOption("c") );
assertTrue( cmd.hasOption("e") );
properties = new Properties();
properties.setProperty( "a", "false" );
properties.setProperty( "c", "no" );
properties.setProperty( "e", "0" );
cmd = parser.parse(opts, null, properties);
assertTrue( !cmd.hasOption("a") );
assertTrue( !cmd.hasOption("c") );
assertTrue( cmd.hasOption("e") ); // this option accepts as argument
properties = new Properties();
properties.setProperty( "a", "TRUE" );
properties.setProperty( "c", "nO" );
properties.setProperty( "e", "TrUe" );
cmd = parser.parse(opts, null, properties);
assertTrue( cmd.hasOption("a") );
assertTrue( !cmd.hasOption("c") );
assertTrue( cmd.hasOption("e") );
properties = new Properties();
properties.setProperty( "a", "just a string" );
properties.setProperty( "e", "" );
cmd = parser.parse(opts, null, properties);
assertTrue( !cmd.hasOption("a") );
assertTrue( !cmd.hasOption("c") );
assertTrue( cmd.hasOption("e") );
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
static String stripLeadingAndTrailingQuotes(String str)
{
if (str.startsWith("\""))
{
str = str.substring(1, str.length());
}
int length = str.length();
if (str.endsWith("\""))
{
str = str.substring(0, length - 1);
}
return str;
}
// Test Case
[/INST]
public void testStripLeadingAndTrailingQuotes()
{
assertEquals("foo", Util.stripLeadingAndTrailingQuotes("\"foo\""));
assertEquals("foo \"bar\"", Util.stripLeadingAndTrailingQuotes("foo \"bar\""));
assertEquals("\"foo\" bar", Util.stripLeadingAndTrailingQuotes("\"foo\" bar"));
assertEquals("\"foo\" and \"bar\"", Util.stripLeadingAndTrailingQuotes("\"foo\" and \"bar\""));
assertEquals("\"", Util.stripLeadingAndTrailingQuotes("\""));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public static Number createNumber(String str)
{
try
{
return NumberUtils.createNumber(str);
}
catch (NumberFormatException nfe)
{
System.err.println(nfe.getMessage());
}
return null;
}
// Test Case
[/INST]
public void testSimplePattern()
{
try {
Options options = PatternOptionBuilder.parsePattern("a:b@cde>f+n%t/");
String[] args = new String[] { "-c", "-a", "foo", "-b", "java.util.Vector", "-e", "build.xml", "-f", "java.util.Calendar", "-n", "4.5", "-t", "http://jakarta.apache.org/" };
CommandLineParser parser = new PosixParser();
CommandLine line = parser.parse(options,args);
// tests the char methods of CommandLine that delegate to
// the String methods
assertEquals("flag a", "foo", line.getOptionValue("a"));
assertEquals("flag a", "foo", line.getOptionValue('a'));
assertEquals("string flag a", "foo", line.getOptionObject("a"));
assertEquals("string flag a", "foo", line.getOptionObject('a'));
assertEquals("object flag b", new java.util.Vector(), line.getOptionObject("b"));
assertEquals("object flag b", new java.util.Vector(), line.getOptionObject('b'));
assertEquals("boolean true flag c", true, line.hasOption("c"));
assertEquals("boolean true flag c", true, line.hasOption('c'));
assertEquals("boolean false flag d", false, line.hasOption("d"));
assertEquals("boolean false flag d", false, line.hasOption('d'));
assertEquals("file flag e", new java.io.File("build.xml"), line.getOptionObject("e"));
assertEquals("file flag e", new java.io.File("build.xml"), line.getOptionObject('e'));
assertEquals("class flag f", java.util.Calendar.class, line.getOptionObject("f"));
assertEquals("class flag f", java.util.Calendar.class, line.getOptionObject('f'));
assertEquals("number flag n", new Double(4.5), line.getOptionObject("n"));
assertEquals("number flag n", new Double(4.5), line.getOptionObject('n'));
assertEquals("url flag t", new java.net.URL("http://jakarta.apache.org/"), line.getOptionObject("t"));
assertEquals("url flag t", new java.net.URL("http://jakarta.apache.org/"), line.getOptionObject('t'));
/// DATES NOT SUPPORTED YET.
// assertEquals("number flag t", new java.util.Date(1023400137276L), line.getOptionObject('z'));
// input is: "Thu Jun 06 17:48:57 EDT 2002"
}
catch( ParseException exp ) {
fail( exp.getMessage() );
}
catch( java.net.MalformedURLException exp ) {
fail( exp.getMessage() );
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void handleProperties(Properties properties) throws ParseException
{
if (properties == null)
{
return;
}
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String option = e.nextElement().toString();
if (!cmd.hasOption(option))
{
Option opt = options.getOption(option);
// if the option is part of a group, check if another option of the group has been selected
// get the value from the properties
String value = properties.getProperty(option);
if (opt.hasArg())
{
if (opt.getValues() == null || opt.getValues().length == 0)
{
opt.addValueForProcessing(value);
}
}
else if (!("yes".equalsIgnoreCase(value)
|| "true".equalsIgnoreCase(value)
|| "1".equalsIgnoreCase(value)))
{
// if the value is not yes, true or 1 then don't add the option to the CommandLine
continue;
}
handleOption(opt);
currentOption = null;
}
}
}
// Test Case
[/INST]
public void testPropertyOptionGroup() throws Exception
{
Options opts = new Options();
OptionGroup group1 = new OptionGroup();
group1.addOption(new Option("a", null));
group1.addOption(new Option("b", null));
opts.addOptionGroup(group1);
OptionGroup group2 = new OptionGroup();
group2.addOption(new Option("x", null));
group2.addOption(new Option("y", null));
opts.addOptionGroup(group2);
String[] args = new String[] { "-a" };
Properties properties = new Properties();
properties.put("b", "true");
properties.put("x", "true");
CommandLine cmd = parse(parser, opts, args, properties);
assertTrue(cmd.hasOption("a"));
assertFalse(cmd.hasOption("b"));
assertTrue(cmd.hasOption("x"));
assertFalse(cmd.hasOption("y"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected void processProperties(Properties properties) throws ParseException
{
if (properties == null)
{
return;
}
for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)
{
String option = e.nextElement().toString();
if (!cmd.hasOption(option))
{
Option opt = getOptions().getOption(option);
// if the option is part of a group, check if another option of the group has been selected
// get the value from the properties instance
String value = properties.getProperty(option);
if (opt.hasArg())
{
if (opt.getValues() == null || opt.getValues().length == 0)
{
try
{
opt.addValueForProcessing(value);
}
catch (RuntimeException exp)
{
// if we cannot add the value don't worry about it
}
}
}
else if (!("yes".equalsIgnoreCase(value)
|| "true".equalsIgnoreCase(value)
|| "1".equalsIgnoreCase(value)))
{
// if the value is not yes, true or 1 then don't add the
// option to the CommandLine
continue;
}
cmd.addOption(opt);
updateRequiredOptions(opt);
}
}
}
// Test Case
[/INST]
public void testPropertyOptionGroup() throws Exception
{
Options opts = new Options();
OptionGroup group1 = new OptionGroup();
group1.addOption(new Option("a", null));
group1.addOption(new Option("b", null));
opts.addOptionGroup(group1);
OptionGroup group2 = new OptionGroup();
group2.addOption(new Option("x", null));
group2.addOption(new Option("y", null));
opts.addOptionGroup(group2);
String[] args = new String[] { "-a" };
Properties properties = new Properties();
properties.put("b", "true");
properties.put("x", "true");
CommandLine cmd = parse(parser, opts, args, properties);
assertTrue(cmd.hasOption("a"));
assertFalse(cmd.hasOption("b"));
assertTrue(cmd.hasOption("x"));
assertFalse(cmd.hasOption("y"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private static void reset()
{
description = null;
argName = "arg";
longopt = null;
type = null;
required = false;
numberOfArgs = Option.UNINITIALIZED;
optionalArg = false;
valuesep = (char) 0;
}
// Test Case
[/INST]
public void testDefaultArgName()
{
Option option = OptionBuilder.hasArg().isRequired().create("f");
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.setArgName("argument");
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f <argument>" + EOL, out.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private void appendOption(final StringBuffer buff, final Option option, final boolean required)
{
if (!required)
{
buff.append("[");
}
if (option.getOpt() != null)
{
buff.append("-").append(option.getOpt());
}
else
{
buff.append("--").append(option.getLongOpt());
}
// if the Option has a value and a non blank argname
if (option.hasArg() && option.hasArgName())
{
buff.append(option.getOpt() == null ? longOptSeparator : " ");
buff.append("<").append(option.getArgName()).append(">");
}
// if the Option is not a required option
if (!required)
{
buff.append("]");
}
}
// Test Case
[/INST]
public void testDefaultArgName()
{
Option option = OptionBuilder.hasArg().isRequired().create("f");
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.setArgName("argument");
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f <argument>" + EOL, out.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testDefaultArgName()
{
Option option = OptionBuilder.hasArg().isRequired().create("f");
Options options = new Options();
options.addOption(option);
StringWriter out = new StringWriter();
HelpFormatter formatter = new HelpFormatter();
formatter.setArgName("argument");
formatter.printUsage(new PrintWriter(out), 80, "app", options);
assertEquals("usage: app -f <argument>" + EOL, out.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
protected int findWrapPos(String text, int width, int startPos)
{
int pos;
// the line ends before the max wrap pos or a new line char found
if (((pos = text.indexOf('\n', startPos)) != -1 && pos <= width)
|| ((pos = text.indexOf('\t', startPos)) != -1 && pos <= width))
{
return pos + 1;
}
else if (startPos + width >= text.length())
{
return -1;
}
// look for the last whitespace character before startPos+width
pos = startPos + width;
char c;
while ((pos >= startPos) && ((c = text.charAt(pos)) != ' ')
&& (c != '\n') && (c != '\r'))
{
--pos;
}
// if we found it - just return
if (pos > startPos)
{
return pos;
}
// if we didn't find one, simply chop at startPos+width
pos = startPos + width;
while ((pos <= text.length()) && ((c = text.charAt(pos)) != ' ')
&& (c != '\n') && (c != '\r'))
{
++pos;
}
return pos == text.length() ? -1 : pos;
}
// Test Case
[/INST]
public void testRenderWrappedTextWordCut()
{
int width = 7;
int padding = 0;
String text = "Thisisatest.";
String expected = "Thisisa" + EOL +
"test.";
StringBuffer sb = new StringBuffer();
new HelpFormatter().renderWrappedText(sb, width, padding, text);
assertEquals("cut and wrap", expected, sb.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public void printWrapped(PrintWriter pw, int width, int nextLineTabStop, String text)
{
StringBuffer sb = new StringBuffer(text.length());
renderWrappedText(sb, width, nextLineTabStop, text);
pw.println(sb.toString());
}
// Test Case
[/INST]
public void testIndentedHeaderAndFooter()
{
// related to CLI-207
Options options = new Options();
HelpFormatter formatter = new HelpFormatter();
String header = " Header1\n Header2";
String footer = " Footer1\n Footer2";
StringWriter out = new StringWriter();
formatter.printHelp(new PrintWriter(out), 80, "foobar", header, options, 2, 2, footer, true);
assertEquals(
"usage: foobar" + EOL +
" Header1" + EOL +
" Header2" + EOL +
"" + EOL +
" Footer1" + EOL +
" Footer2" + EOL
, out.toString());
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private static void reset()
{
description = null;
argName = null;
longopt = null;
type = null;
required = false;
numberOfArgs = Option.UNINITIALIZED;
optionalArg = false;
valuesep = (char) 0;
}
// Test Case
[/INST]
public void testGetParsedOptionValue() throws Exception {
Options options = new Options();
options.addOption(OptionBuilder.hasArg().withType(Number.class).create("i"));
options.addOption(OptionBuilder.hasArg().create("f"));
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, new String[] { "-i", "123", "-f", "foo" });
assertEquals(123, ((Number) cmd.getParsedOptionValue("i")).intValue());
assertEquals("foo", cmd.getParsedOptionValue("f"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
public void testGetParsedOptionValue() throws Exception {
Options options = new Options();
options.addOption(OptionBuilder.hasArg().withType(Number.class).create("i"));
options.addOption(OptionBuilder.hasArg().create("f"));
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, new String[] { "-i", "123", "-f", "foo" });
assertEquals(123, ((Number) cmd.getParsedOptionValue("i")).intValue());
assertEquals("foo", cmd.getParsedOptionValue("f"));
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
public List<String> getMatchingOptions(String opt)
{
opt = Util.stripLeadingHyphens(opt);
List<String> matchingOpts = new ArrayList<String>();
// for a perfect match return the single option only
for (String longOpt : longOpts.keySet())
{
if (longOpt.startsWith(opt))
{
matchingOpts.add(longOpt);
}
}
return matchingOpts;
}
// Test Case
[/INST]
@Test
public void testExactOptionNameMatch() throws ParseException {
new DefaultParser().parse(getOptions(), new String[]{"--prefix"});
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
@Test
public void testOptionComparatorInsertedOrder() throws ParseException {
Collection<Option> options = getOptions().getOptions();
int i = 0;
for(Option o: options) {
Assert.assertEquals(o.getOpt(), insertedOrder.get(i));
i++;
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
x
// Test Case
[/INST]
@Test
public void testOptionComparatorInsertedOrder() throws ParseException {
Collection<Option> options = getOptions().getOptions();
int i = 0;
for(Option o: options) {
Assert.assertEquals(o.getOpt(), insertedOrder.get(i));
i++;
}
}
</s>
|
<s>[INST] <<SYS>>
You are a helpful assistant. Generate a test case that triggers the bug for the buggy function.
<</SYS>>
// Buggy Function
private boolean isShortOption(String token)
{
// short options (-S, -SV, -S=V, -SV1=V2, -S1S2)
return token.startsWith("-") && token.length() >= 2 && options.hasShortOption(token.substring(1, 2));
// remove leading "-" and "=value"
}
// Test Case
[/INST]
@Test
public void shouldParseShortOptionWithoutValue() throws Exception {
String[] twoShortOptions = new String[]{"-t1", "-last"};
final CommandLine commandLine = parser.parse(options, twoShortOptions);
assertTrue(commandLine.hasOption("t1"));
assertNotEquals("Second option has been used as value for first option", "-last", commandLine.getOptionValue("t1"));
assertTrue("Second option has not been detected", commandLine.hasOption("last"));
}
</s>
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 5