repo_name
stringlengths 7
104
| file_path
stringlengths 13
198
| context
stringlengths 67
7.15k
| import_statement
stringlengths 16
4.43k
| code
stringlengths 40
6.98k
| prompt
stringlengths 227
8.27k
| next_line
stringlengths 8
795
|
|---|---|---|---|---|---|---|
jawher/moulder-j
|
src/main/java/moulder/moulds/RemoveCssClassMoulder.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SimpleValue.java
// public class SimpleValue<T> implements Value<T> {
// private final T value;
//
// /**
// * @param value the value to be returned by {@link #get()}
// */
// public SimpleValue(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import moulder.Moulder;
import moulder.Value;
import moulder.values.SimpleValue;
|
package moulder.moulds;
/**
* Moulder, which removes a CSS class.
*/
public class RemoveCssClassMoulder implements Moulder {
private final Value<String> value;
/**
* @param value
* a value that returns the CSS class
*/
public RemoveCssClassMoulder(Value<String> value) {
this.value = value;
}
/**
* @param cssClass
* the CSS class
*/
public RemoveCssClassMoulder(String cssClass) {
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SimpleValue.java
// public class SimpleValue<T> implements Value<T> {
// private final T value;
//
// /**
// * @param value the value to be returned by {@link #get()}
// */
// public SimpleValue(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/RemoveCssClassMoulder.java
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import moulder.Moulder;
import moulder.Value;
import moulder.values.SimpleValue;
package moulder.moulds;
/**
* Moulder, which removes a CSS class.
*/
public class RemoveCssClassMoulder implements Moulder {
private final Value<String> value;
/**
* @param value
* a value that returns the CSS class
*/
public RemoveCssClassMoulder(Value<String> value) {
this.value = value;
}
/**
* @param cssClass
* the CSS class
*/
public RemoveCssClassMoulder(String cssClass) {
|
this(new SimpleValue<String>(cssClass));
|
jawher/moulder-j
|
src/test/java/moulder/moulds/ChildAppenderTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class ChildAppenderTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/ChildAppenderTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class ChildAppenderTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
Value<Iterable<Node>> content = mock(Value.class);
|
jawher/moulder-j
|
src/main/java/moulder/values/Values.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import java.io.InputStream;
import java.util.Iterator;
|
package moulder.values;
/**
* A class with a bunch of static factory methods to common values
*
* @author jawher
*/
public class Values {
public static HtmlValue html(String html) {
return new HtmlValue(html);
}
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/main/java/moulder/values/Values.java
import moulder.Value;
import java.io.InputStream;
import java.util.Iterator;
package moulder.values;
/**
* A class with a bunch of static factory methods to common values
*
* @author jawher
*/
public class Values {
public static HtmlValue html(String html) {
return new HtmlValue(html);
}
|
public static HtmlValue html(Value<String> html) {
|
jawher/moulder-j
|
src/test/java/moulder/moulds/ChildPrependerTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class ChildPrependerTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/ChildPrependerTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class ChildPrependerTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
Value<Iterable<Node>> content = mock(Value.class);
|
jawher/moulder-j
|
src/test/java/moulder/moulds/AddCssClassMoulderTest.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
|
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import java.io.StringReader;
import java.util.List;
import moulder.Moulder;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
|
package moulder.moulds;
public class AddCssClassMoulderTest extends BaseMoulderTest {
@Test
public void noClass() throws Exception {
final String bodyHtml = "<tag>text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
@Test
public void withSameClass() throws Exception {
final String bodyHtml = "<tag class=\"ss\">text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
@Test
public void withSimilarClass() throws Exception {
final String bodyHtml = "<tag class=\"sss ss1\">text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"sss ss1 ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
private void test(String bodyHtml, String cssClass, String expected) throws Exception {
Document document = Jsoup.parseBodyFragment(bodyHtml);
Element element = document.getElementsByTag("tag").first();
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
// Path: src/test/java/moulder/moulds/AddCssClassMoulderTest.java
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import java.io.StringReader;
import java.util.List;
import moulder.Moulder;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
package moulder.moulds;
public class AddCssClassMoulderTest extends BaseMoulderTest {
@Test
public void noClass() throws Exception {
final String bodyHtml = "<tag>text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
@Test
public void withSameClass() throws Exception {
final String bodyHtml = "<tag class=\"ss\">text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
@Test
public void withSimilarClass() throws Exception {
final String bodyHtml = "<tag class=\"sss ss1\">text</tag>";
final String cssClass = "ss";
final String expected = "<tag class=\"sss ss1 ss\">text\n</tag>";
test(bodyHtml, cssClass, expected);
}
private void test(String bodyHtml, String cssClass, String expected) throws Exception {
Document document = Jsoup.parseBodyFragment(bodyHtml);
Element element = document.getElementsByTag("tag").first();
|
Moulder moulder = new AddCssClassMoulder(cssClass);
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Moulds.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
|
}
public static Repeater repeat(int count) {
return new Repeater(count);
}
public static Remover remove() {
return new Remover();
}
public static Remover remove(Value<Boolean> remove) {
return new Remover(remove);
}
public static AttrModifier attr(String attr, String value) {
return new AttrModifier(attr, value);
}
public static AttrModifier attr(String attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/Moulds.java
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
}
public static Repeater repeat(int count) {
return new Repeater(count);
}
public static Remover remove() {
return new Remover();
}
public static Remover remove(Value<Boolean> remove) {
return new Remover(remove);
}
public static AttrModifier attr(String attr, String value) {
return new AttrModifier(attr, value);
}
public static AttrModifier attr(String attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
|
public static IfMoulder ifm(Value<Boolean> condition, Moulder thenMoulder, Moulder elseMoulder) {
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Moulds.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
|
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
public static IfMoulder ifm(Value<Boolean> condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static IfMoulder ifm(boolean condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static SubMoulder sub(String selector, Moulder... moulders) {
return new SubMoulder().register(selector, moulders);
}
public static SubMoulder sub(String selector, List<Moulder> moulders) {
return new SubMoulder().register(selector, moulders);
}
public static Filterer filter(String selector) {
return new Filterer(selector);
}
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/Moulds.java
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
public static IfMoulder ifm(Value<Boolean> condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static IfMoulder ifm(boolean condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static SubMoulder sub(String selector, Moulder... moulders) {
return new SubMoulder().register(selector, moulders);
}
public static SubMoulder sub(String selector, List<Moulder> moulders) {
return new SubMoulder().register(selector, moulders);
}
public static Filterer filter(String selector) {
return new Filterer(selector);
}
|
public static <T> ForEach<T> forEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Moulds.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
|
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
public static IfMoulder ifm(Value<Boolean> condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static IfMoulder ifm(boolean condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static SubMoulder sub(String selector, Moulder... moulders) {
return new SubMoulder().register(selector, moulders);
}
public static SubMoulder sub(String selector, List<Moulder> moulders) {
return new SubMoulder().register(selector, moulders);
}
public static Filterer filter(String selector) {
return new Filterer(selector);
}
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/Moulds.java
import moulder.Moulder;
import moulder.Value;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Node;
import java.util.List;
}
public static AttrModifier attr(Value<String> attr, Value<String> value) {
return new AttrModifier(attr, value);
}
public static NopMoulder nop() {
return new NopMoulder();
}
public static IfMoulder ifm(Value<Boolean> condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static IfMoulder ifm(boolean condition, Moulder thenMoulder, Moulder elseMoulder) {
return new IfMoulder(condition, thenMoulder, elseMoulder);
}
public static SubMoulder sub(String selector, Moulder... moulders) {
return new SubMoulder().register(selector, moulders);
}
public static SubMoulder sub(String selector, List<Moulder> moulders) {
return new SubMoulder().register(selector, moulders);
}
public static Filterer filter(String selector) {
return new Filterer(selector);
}
|
public static <T> ForEach<T> forEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
|
jawher/moulder-j
|
src/test/java/moulder/moulds/AttrModifierTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class AttrModifierTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/AttrModifierTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class AttrModifierTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
Value<String> attr = mock(Value.class);
|
jawher/moulder-j
|
src/test/java/moulder/moulds/RepeaterTest.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
|
import moulder.Moulder;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
|
package moulder.moulds;
public class RepeaterTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
Repeater a = new Repeater(2);
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'>test</outer></body></html>");
Element element = document.getElementsByTag("outer").first();
List<Node> processed = a.process(element);
// check for correct repetition of html
assertXMLEqual(new StringReader("<body>" + "<outer a='v'>test</outer><outer a='v'>test</outer>"+ "</body>"), new StringReader(
html(processed)));
}
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
// Path: src/test/java/moulder/moulds/RepeaterTest.java
import moulder.Moulder;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
package moulder.moulds;
public class RepeaterTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
Repeater a = new Repeater(2);
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'>test</outer></body></html>");
Element element = document.getElementsByTag("outer").first();
List<Node> processed = a.process(element);
// check for correct repetition of html
assertXMLEqual(new StringReader("<body>" + "<outer a='v'>test</outer><outer a='v'>test</outer>"+ "</body>"), new StringReader(
html(processed)));
}
|
private Moulder produce(final String html1, final String html2) {
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Prepender.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/HtmlValue.java
// public class HtmlValue implements Value<Iterable<Node>> {
// private Value<String> html;
//
// public HtmlValue(String html) {
// this(new SimpleValue<String>(html));
// }
//
// public HtmlValue(Value<String> html) {
// super();
// this.html = html;
// }
//
// public Iterable<Node> get() {
// List<Node> nodes = Jsoup.parseBodyFragment(html.get()).body()
// .childNodes();
// List<Node> copy = new ArrayList<Node>(nodes);
// return copy;
// }
//
// }
|
import moulder.Moulder;
import moulder.Value;
import moulder.values.HtmlValue;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
|
package moulder.moulds;
/**
* A moulder that prepends content before its input element
*
* @author jawher
*
*/
public class Prepender implements Moulder {
private Value<Iterable<Node>> content;
/**
*
* @param content
* the nodes that are to be prepended before the input element.
*/
public Prepender(Value<Iterable<Node>> content) {
super();
this.content = content;
}
/**
* a convenience version of the {@link #Prepender(moulder.Value)} constructor that
* parses the supplied <code>html</code> string.
*
* @param html
*/
public Prepender(String html) {
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/HtmlValue.java
// public class HtmlValue implements Value<Iterable<Node>> {
// private Value<String> html;
//
// public HtmlValue(String html) {
// this(new SimpleValue<String>(html));
// }
//
// public HtmlValue(Value<String> html) {
// super();
// this.html = html;
// }
//
// public Iterable<Node> get() {
// List<Node> nodes = Jsoup.parseBodyFragment(html.get()).body()
// .childNodes();
// List<Node> copy = new ArrayList<Node>(nodes);
// return copy;
// }
//
// }
// Path: src/main/java/moulder/moulds/Prepender.java
import moulder.Moulder;
import moulder.Value;
import moulder.values.HtmlValue;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
package moulder.moulds;
/**
* A moulder that prepends content before its input element
*
* @author jawher
*
*/
public class Prepender implements Moulder {
private Value<Iterable<Node>> content;
/**
*
* @param content
* the nodes that are to be prepended before the input element.
*/
public Prepender(Value<Iterable<Node>> content) {
super();
this.content = content;
}
/**
* a convenience version of the {@link #Prepender(moulder.Value)} constructor that
* parses the supplied <code>html</code> string.
*
* @param html
*/
public Prepender(String html) {
|
this(new HtmlValue(html));
|
jawher/moulder-j
|
src/test/java/moulder/moulds/RemoverTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class RemoverTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
Remover a = new Remover();
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'>test</outer>text</body></html>");
Element element = document.getElementsByTag("outer").first();
List<Node> processed = a.process(element);
assertXMLEqual(new StringReader(
"<body></body>"),
new StringReader(html(processed)));
}
@Test
public void testWithValue() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/RemoverTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class RemoverTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
Remover a = new Remover();
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'>test</outer>text</body></html>");
Element element = document.getElementsByTag("outer").first();
List<Node> processed = a.process(element);
assertXMLEqual(new StringReader(
"<body></body>"),
new StringReader(html(processed)));
}
@Test
public void testWithValue() throws Exception {
|
Value<Boolean> visibility = mock(Value.class);
|
jawher/moulder-j
|
src/main/java/moulder/moulds/ForEach.java
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
|
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/ForEach.java
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
|
private final SeqValue<T> seq;
|
jawher/moulder-j
|
src/main/java/moulder/moulds/ForEach.java
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
|
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
private final SeqValue<T> seq;
private final List<Moulder> body;
public ForEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
this(box, seq, Arrays.asList(body));
}
public ForEach(SimpleBox<T> box, SeqValue<T> seq, List<Moulder> body) {
this.box = box;
this.seq = seq;
this.body = body;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
T o;
while ((o = seq.get()) != null) {
box.set(o);
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/ForEach.java
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
private final SeqValue<T> seq;
private final List<Moulder> body;
public ForEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
this(box, seq, Arrays.asList(body));
}
public ForEach(SimpleBox<T> box, SeqValue<T> seq, List<Moulder> body) {
this.box = box;
this.seq = seq;
this.body = body;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
T o;
while ((o = seq.get()) != null) {
box.set(o);
|
res.addAll(applyMoulders(body, Arrays.<Node> asList(copy(element))));
|
jawher/moulder-j
|
src/main/java/moulder/moulds/ForEach.java
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
|
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
private final SeqValue<T> seq;
private final List<Moulder> body;
public ForEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
this(box, seq, Arrays.asList(body));
}
public ForEach(SimpleBox<T> box, SeqValue<T> seq, List<Moulder> body) {
this.box = box;
this.seq = seq;
this.body = body;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
T o;
while ((o = seq.get()) != null) {
box.set(o);
|
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
//
// Path: src/main/java/moulder/moulds/helpers/MouldersApplier.java
// public static Collection<Node> applyMoulders(Collection<Moulder> moulders, Collection<Node> nodes) {
// if(moulders.isEmpty()) {
// return nodes;
// } else {
// Collection<Node> workingSet = new ArrayList<Node>(nodes);
// for(Moulder moulder: moulders) {
// workingSet = applyMoulder(moulder, workingSet);
// }
// return workingSet;
// }
// }
//
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/values/SeqValue.java
// public class SeqValue<T> implements Value<T> {
// private Iterator<T> values;
//
// public SeqValue(Iterator<T> values) {
// super();
// this.values = values;
// }
//
// public SeqValue(Iterable<T> values) {
// this.values = values.iterator();
// }
//
// public SeqValue(T... values) {
// this.values = Arrays.asList(values).iterator();
// }
//
// public T get() {
// return values.hasNext() ? values.next() : null;
// }
//
// public SeqValue<T> cycle() {
// return new SeqValue<T>(new CyclingIterator<T>(values));
// }
//
// private static final class CyclingIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private final List<S> values = new ArrayList<S>();
// private boolean cycled = false;
//
// public CyclingIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// S res = it.next();
// if (!cycled) {
// values.add(res);
// }
// return res;
// } else {
// cycled = true;
// it = values.iterator();
// return next();
// }
// }
//
// public void remove() {
//
// }
//
// }
//
// public SeqValue<T> repeatLast() {
// return new SeqValue<T>(new RepeatLastIterator<T>(values));
// }
//
// private static final class RepeatLastIterator<S> implements Iterator<S> {
// private Iterator<S> it;
// private final boolean itHasValues;
// private S last;
//
// public RepeatLastIterator(Iterator<S> it) {
// this.it = it;
// itHasValues = it.hasNext();
// }
//
// public boolean hasNext() {
// return itHasValues;
// }
//
// public S next() {
// if (!itHasValues) {
// throw new NoSuchElementException();
// }
// if (it.hasNext()) {
// last = it.next();
// }
// return last;
// }
//
// public void remove() {
//
// }
//
// }
// }
//
// Path: src/main/java/moulder/values/SimpleBox.java
// public class SimpleBox<T> implements Value<T> {
//
// private T value;
//
// public SimpleBox() {
// this.value = null;
// }
//
// public SimpleBox(T value) {
// this.value = value;
// }
//
// public void set(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/ForEach.java
import static moulder.moulds.helpers.JsoupHelper.copy;
import static moulder.moulds.helpers.MouldersApplier.applyMoulders;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import moulder.Moulder;
import moulder.values.SeqValue;
import moulder.values.SimpleBox;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
package moulder.moulds;
/**
* A moulder, that will repeatedly invoke the body moulders for each item in the
* seq. They can access the current item using the box.
*/
public class ForEach<T> implements Moulder {
private final SimpleBox<T> box;
private final SeqValue<T> seq;
private final List<Moulder> body;
public ForEach(SimpleBox<T> box, SeqValue<T> seq, Moulder... body) {
this(box, seq, Arrays.asList(body));
}
public ForEach(SimpleBox<T> box, SeqValue<T> seq, List<Moulder> body) {
this.box = box;
this.seq = seq;
this.body = body;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
T o;
while ((o = seq.get()) != null) {
box.set(o);
|
res.addAll(applyMoulders(body, Arrays.<Node> asList(copy(element))));
|
jawher/moulder-j
|
src/test/java/moulder/moulds/IfMoulderTest.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Moulder;
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class IfMoulderTest extends BaseMoulderTest {
@Test
public void testThen() throws Exception {
test(true, "<body><b>text</b>text</body>");
}
@Test
public void testElse() throws Exception {
test(false, "<body><c>content</c>text</body>");
}
private void test(boolean res, String expected) throws Exception {
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/IfMoulderTest.java
import moulder.Moulder;
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class IfMoulderTest extends BaseMoulderTest {
@Test
public void testThen() throws Exception {
test(true, "<body><b>text</b>text</body>");
}
@Test
public void testElse() throws Exception {
test(false, "<body><c>content</c>text</body>");
}
private void test(boolean res, String expected) throws Exception {
|
Value<Boolean> condition = mock(Value.class);
|
jawher/moulder-j
|
src/test/java/moulder/moulds/IfMoulderTest.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Moulder;
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class IfMoulderTest extends BaseMoulderTest {
@Test
public void testThen() throws Exception {
test(true, "<body><b>text</b>text</body>");
}
@Test
public void testElse() throws Exception {
test(false, "<body><c>content</c>text</body>");
}
private void test(boolean res, String expected) throws Exception {
Value<Boolean> condition = mock(Value.class);
when(condition.get()).thenReturn(res);
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'><a>test</a></outer></body></html>");
Element element = document.getElementsByTag("outer").first();
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/IfMoulderTest.java
import moulder.Moulder;
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.Arrays;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class IfMoulderTest extends BaseMoulderTest {
@Test
public void testThen() throws Exception {
test(true, "<body><b>text</b>text</body>");
}
@Test
public void testElse() throws Exception {
test(false, "<body><c>content</c>text</body>");
}
private void test(boolean res, String expected) throws Exception {
Value<Boolean> condition = mock(Value.class);
when(condition.get()).thenReturn(res);
Document document = Jsoup
.parseBodyFragment("<html><body><outer a='v'><a>test</a></outer></body></html>");
Element element = document.getElementsByTag("outer").first();
|
Moulder thenMoulder = mock(Moulder.class);
|
jawher/moulder-j
|
src/test/java/moulder/moulds/TexterTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class TexterTest extends BaseMoulderTest {
@Test
public void testRegularText() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/TexterTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class TexterTest extends BaseMoulderTest {
@Test
public void testRegularText() throws Exception {
|
Value<String> text = mock(Value.class);
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Texter.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SimpleValue.java
// public class SimpleValue<T> implements Value<T> {
// private final T value;
//
// /**
// * @param value the value to be returned by {@link #get()}
// */
// public SimpleValue(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
|
import moulder.Moulder;
import moulder.Value;
import moulder.values.SimpleValue;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
|
package moulder.moulds;
/**
* A moulder that sets its input element text content
*
* @author jawher
*/
public class Texter implements Moulder {
private Value<?> text;
/**
* @param text a value that returns the text to be used to set its input
* element's content
*/
public Texter(Value<?> text) {
this.text = text;
}
/**
* A convenience version of {@link #Texter(Value)} that wraps its argument
* in a {@link SimpleValue}
*
* @param text
*/
public Texter(String text) {
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
//
// Path: src/main/java/moulder/values/SimpleValue.java
// public class SimpleValue<T> implements Value<T> {
// private final T value;
//
// /**
// * @param value the value to be returned by {@link #get()}
// */
// public SimpleValue(T value) {
// this.value = value;
// }
//
// public T get() {
// return value;
// }
// }
// Path: src/main/java/moulder/moulds/Texter.java
import moulder.Moulder;
import moulder.Value;
import moulder.values.SimpleValue;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
package moulder.moulds;
/**
* A moulder that sets its input element text content
*
* @author jawher
*/
public class Texter implements Moulder {
private Value<?> text;
/**
* @param text a value that returns the text to be used to set its input
* element's content
*/
public Texter(Value<?> text) {
this.text = text;
}
/**
* A convenience version of {@link #Texter(Value)} that wraps its argument
* in a {@link SimpleValue}
*
* @param text
*/
public Texter(String text) {
|
this(new SimpleValue<String>(text));
|
jawher/moulder-j
|
src/main/java/moulder/moulds/Repeater.java
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public class JsoupHelper {
//
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
// }
|
import moulder.Moulder;
import moulder.moulds.helpers.JsoupHelper;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
|
package moulder.moulds;
/**
* A moulder that repeats its input element
*
* @author jawher
*/
public class Repeater implements Moulder {
private final int count;
/**
* Creates a moulder that duplicates its input element <code>count</code> times
*
* @param count the number of duplicates to produce
*/
public Repeater(int count) {
this.count = count;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
for (int index = 0; index < count; index++) {
|
// Path: src/main/java/moulder/Moulder.java
// public interface Moulder {
// /**
// * This is where a moulder can process the input element to generate its
// * result.
// *
// * @param element the element and its associated data to process
// * @return the list of nodes and their associated data that were generated
// * after processing the input element.
// */
// List<Node> process(Element element);
// }
//
// Path: src/main/java/moulder/moulds/helpers/JsoupHelper.java
// public class JsoupHelper {
//
// public static Element copy(Element e) {
// Element res = new Element(Tag.valueOf(e.tagName()), e.baseUri());
// for (Attribute a: e.attributes()) {
// res.attr(a.getKey(), a.getValue());
// }
// res.html(e.html());
// return res;
// }
// }
// Path: src/main/java/moulder/moulds/Repeater.java
import moulder.Moulder;
import moulder.moulds.helpers.JsoupHelper;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import java.util.ArrayList;
import java.util.List;
package moulder.moulds;
/**
* A moulder that repeats its input element
*
* @author jawher
*/
public class Repeater implements Moulder {
private final int count;
/**
* Creates a moulder that duplicates its input element <code>count</code> times
*
* @param count the number of duplicates to produce
*/
public Repeater(int count) {
this.count = count;
}
public List<Node> process(Element element) {
List<Node> res = new ArrayList<Node>();
for (int index = 0; index < count; index++) {
|
res.add(JsoupHelper.copy(element));
|
jawher/moulder-j
|
src/test/java/moulder/moulds/AppenderTest.java
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
|
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
|
package moulder.moulds;
public class AppenderTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
// Path: src/main/java/moulder/Value.java
// public interface Value<T> {
// /**
// *
// * @return the generated value
// */
// T get();
// }
// Path: src/test/java/moulder/moulds/AppenderTest.java
import moulder.Value;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.junit.Test;
import org.mockito.InOrder;
import java.io.StringReader;
import java.util.List;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.mockito.Mockito.*;
package moulder.moulds;
public class AppenderTest extends BaseMoulderTest {
@Test
public void test() throws Exception {
|
Value<Iterable<Node>> content = mock(Value.class);
|
highsource/maven-jaxb2-plugin
|
plugin/src/test/java/org/jvnet/jaxb2/maven2/JAXBGenerateTest.java
|
// Path: plugin/src/main/java/org/jvnet/mjiip/v_2/XJC2Mojo.java
// @Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES, requiresDependencyResolution = ResolutionScope.COMPILE, requiresDependencyCollection = ResolutionScope.COMPILE, threadSafe = true)
// public class XJC2Mojo extends XJC23Mojo {
//
// private final org.jvnet.jaxb2.maven2.OptionsFactory<Options> optionsFactory = new OptionsFactory();
//
// @Override
// protected org.jvnet.jaxb2.maven2.OptionsFactory<Options> getOptionsFactory() {
// return optionsFactory;
// }
// }
|
import java.io.File;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.DefaultArtifactRepository;
import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.testing.AbstractMojoTestCase;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.jvnet.mjiip.v_2.XJC2Mojo;
|
/*
* Copyright [2006] java.net
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jvnet.jaxb2.maven2;
public abstract class JAXBGenerateTest extends AbstractMojoTestCase {
static {
System.setProperty("basedir", getBaseDir().getAbsolutePath());
}
protected MavenProjectBuilder mavenProjectBuilder;
protected void setUp() throws Exception {
super.setUp();
mavenProjectBuilder = (MavenProjectBuilder) getContainer().lookup(
MavenProjectBuilder.ROLE);
}
protected static File getBaseDir() {
try {
return (new File(JAXBGenerateTest.class.getProtectionDomain()
.getCodeSource().getLocation().getFile())).getParentFile()
.getParentFile().getAbsoluteFile();
} catch (Exception ex) {
throw new AssertionError(ex);
}
}
/**
* Validate the generation of a java files from purchaseorder.xsd.
*
* @throws MojoExecutionException
*/
public void testExecute() throws Exception {
final File pom = new File(getBaseDir(),
"src/test/resources/test-pom.xml");
final ArtifactRepository localRepository = new DefaultArtifactRepository( "local",
new File(getBaseDir(), "target/test-repository").toURI().toURL().toString() , new DefaultRepositoryLayout());
final MavenProject mavenProject = mavenProjectBuilder.build(pom, localRepository, null);
|
// Path: plugin/src/main/java/org/jvnet/mjiip/v_2/XJC2Mojo.java
// @Mojo(name = "generate", defaultPhase = LifecyclePhase.GENERATE_SOURCES, requiresDependencyResolution = ResolutionScope.COMPILE, requiresDependencyCollection = ResolutionScope.COMPILE, threadSafe = true)
// public class XJC2Mojo extends XJC23Mojo {
//
// private final org.jvnet.jaxb2.maven2.OptionsFactory<Options> optionsFactory = new OptionsFactory();
//
// @Override
// protected org.jvnet.jaxb2.maven2.OptionsFactory<Options> getOptionsFactory() {
// return optionsFactory;
// }
// }
// Path: plugin/src/test/java/org/jvnet/jaxb2/maven2/JAXBGenerateTest.java
import java.io.File;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.repository.DefaultArtifactRepository;
import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.testing.AbstractMojoTestCase;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.jvnet.mjiip.v_2.XJC2Mojo;
/*
* Copyright [2006] java.net
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jvnet.jaxb2.maven2;
public abstract class JAXBGenerateTest extends AbstractMojoTestCase {
static {
System.setProperty("basedir", getBaseDir().getAbsolutePath());
}
protected MavenProjectBuilder mavenProjectBuilder;
protected void setUp() throws Exception {
super.setUp();
mavenProjectBuilder = (MavenProjectBuilder) getContainer().lookup(
MavenProjectBuilder.ROLE);
}
protected static File getBaseDir() {
try {
return (new File(JAXBGenerateTest.class.getProtectionDomain()
.getCodeSource().getLocation().getFile())).getParentFile()
.getParentFile().getAbsoluteFile();
} catch (Exception ex) {
throw new AssertionError(ex);
}
}
/**
* Validate the generation of a java files from purchaseorder.xsd.
*
* @throws MojoExecutionException
*/
public void testExecute() throws Exception {
final File pom = new File(getBaseDir(),
"src/test/resources/test-pom.xml");
final ArtifactRepository localRepository = new DefaultArtifactRepository( "local",
new File(getBaseDir(), "target/test-repository").toURI().toURL().toString() , new DefaultRepositoryLayout());
final MavenProject mavenProject = mavenProjectBuilder.build(pom, localRepository, null);
|
final XJC2Mojo generator = (XJC2Mojo) lookupMojo("generate", pom);
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/IOUtils.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
|
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.Scanner;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
import org.sonatype.plexus.build.incremental.BuildContext;
import org.xml.sax.InputSource;
|
package org.jvnet.jaxb2.maven2.util;
public class IOUtils {
/**
* Creates an input source for the given file.
*
* @param file
* file to create input source for.
*
* @return Created input source object.
*/
public static InputSource getInputSource(File file) {
try {
final URL url = file.toURI().toURL();
return getInputSource(url);
} catch (MalformedURLException e) {
return new InputSource(file.getPath());
}
}
public static InputSource getInputSource(final URL url) {
return new InputSource(StringUtils.escapeSpace(url.toExternalForm()));
}
public static InputSource getInputSource(final URI uri) {
return new InputSource(StringUtils.escapeSpace(uri.toString()));
}
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/IOUtils.java
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.Scanner;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
import org.sonatype.plexus.build.incremental.BuildContext;
import org.xml.sax.InputSource;
package org.jvnet.jaxb2.maven2.util;
public class IOUtils {
/**
* Creates an input source for the given file.
*
* @param file
* file to create input source for.
*
* @return Created input source object.
*/
public static InputSource getInputSource(File file) {
try {
final URL url = file.toURI().toURL();
return getInputSource(url);
} catch (MalformedURLException e) {
return new InputSource(file.getPath());
}
}
public static InputSource getInputSource(final URL url) {
return new InputSource(StringUtils.escapeSpace(url.toExternalForm()));
}
public static InputSource getInputSource(final URI uri) {
return new InputSource(StringUtils.escapeSpace(uri.toString()));
}
|
public static final Function<File, URL> GET_URL = new Function<File, URL>() {
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/test/java/org/jvnet/jaxb2/maven2/tests/DependencyResourceTest.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/DependencyResource.java
// public class DependencyResource extends Dependency {
//
// private static final long serialVersionUID = -7680130645800522100L;
// private String resource;
//
// public String getResource() {
// return resource;
// }
//
// public void setResource(String resource) {
// this.resource = resource;
// }
//
// public DependencyResource() {
// setScope(Artifact.SCOPE_RUNTIME);
// }
//
// public String toString() {
// return "Dependency {groupId=" + getGroupId() + ", artifactId="
// + getArtifactId() + ", version=" + getVersion() + ", type="
// + getType() + ", classifier=" + getClassifier() + ", resource="
// + getResource() + "}";
// }
//
// private String systemId;
//
// public void setSystemId(String systemId) {
// this.systemId = systemId;
// }
//
// public String getSystemId() {
// if (this.systemId != null) {
// return this.systemId;
// } else {
// // maven:groupId:artifactId:type:classifier:version!/resource/path/in/jar/schema.xsd
// StringBuilder sb = new StringBuilder();
// sb.append(MavenCatalogResolver.URI_SCHEME_MAVEN).append(':');
// sb.append(getGroupId()).append(':');
// sb.append(getArtifactId()).append(':');
// sb.append(getType() == null ? "" : getType()).append(':');
// sb.append(getClassifier() == null ? "" : getClassifier()).append(
// ':');
// sb.append(getVersion() == null ? "" : getVersion());
// sb.append("!/");
// sb.append(getResource());
// return sb.toString();
// }
// }
//
// public static DependencyResource valueOf(String value)
// throws IllegalArgumentException {
//
// final String resourceDelimiter = "!/";
// final int resourceDelimiterPosition = value.indexOf(resourceDelimiter);
//
// final String dependencyPart;
// final String resource;
// if (resourceDelimiterPosition == -1) {
// dependencyPart = value;
// resource = "";
// } else {
// dependencyPart = value.substring(0, resourceDelimiterPosition);
// resource = value.substring(resourceDelimiterPosition
// + resourceDelimiter.length());
// }
//
// final String[] dependencyParts = StringUtils.split(dependencyPart, ':',
// true);
//
// if (dependencyParts.length < 2) {
// throw new IllegalArgumentException(
// MessageFormat
// .format("Error parsing dependency descriptor [{0}], both groupId and artifactId must be specified.",
// dependencyPart));
// }
//
// if (dependencyParts.length > 5) {
// throw new IllegalArgumentException(
// MessageFormat
// .format("Error parsing dependency descriptor [{0}], it contains too many parts.",
// dependencyPart));
// }
//
// final String groupId = dependencyParts[0];
// final String artifactId = dependencyParts[1];
// final String version;
//
// final String type;
//
// if (dependencyParts.length > 2) {
// type = (dependencyParts[2] == null || dependencyParts[2].length() == 0) ? null
// : dependencyParts[2];
// } else {
// type = null;
// }
//
// final String classifier;
//
// if (dependencyParts.length > 3) {
// classifier = (dependencyParts[3] == null || dependencyParts[3]
// .length() == 0) ? null : dependencyParts[3];
// } else {
// classifier = null;
// }
//
// if (dependencyParts.length > 4) {
// version = (dependencyParts[4] == null || dependencyParts[4]
// .length() == 0) ? null : dependencyParts[4];
// } else {
// version = null;
// }
//
// final DependencyResource dependencyResource = new DependencyResource();
//
// dependencyResource.setGroupId(groupId);
// dependencyResource.setArtifactId(artifactId);
// if (version != null) {
// dependencyResource.setVersion(version);
// }
// if (type != null) {
// dependencyResource.setType(type);
// }
// if (classifier != null) {
// dependencyResource.setClassifier(classifier);
// }
// if (resource != null) {
// dependencyResource.setResource(resource);
// }
// dependencyResource.setSystemId(value);
// return dependencyResource;
// }
// }
|
import org.junit.Test;
import org.jvnet.jaxb2.maven2.DependencyResource;
|
package org.jvnet.jaxb2.maven2.tests;
public class DependencyResourceTest {
@Test
public void correctlyParsesDepenencyResource() {
{
@SuppressWarnings("unused")
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/DependencyResource.java
// public class DependencyResource extends Dependency {
//
// private static final long serialVersionUID = -7680130645800522100L;
// private String resource;
//
// public String getResource() {
// return resource;
// }
//
// public void setResource(String resource) {
// this.resource = resource;
// }
//
// public DependencyResource() {
// setScope(Artifact.SCOPE_RUNTIME);
// }
//
// public String toString() {
// return "Dependency {groupId=" + getGroupId() + ", artifactId="
// + getArtifactId() + ", version=" + getVersion() + ", type="
// + getType() + ", classifier=" + getClassifier() + ", resource="
// + getResource() + "}";
// }
//
// private String systemId;
//
// public void setSystemId(String systemId) {
// this.systemId = systemId;
// }
//
// public String getSystemId() {
// if (this.systemId != null) {
// return this.systemId;
// } else {
// // maven:groupId:artifactId:type:classifier:version!/resource/path/in/jar/schema.xsd
// StringBuilder sb = new StringBuilder();
// sb.append(MavenCatalogResolver.URI_SCHEME_MAVEN).append(':');
// sb.append(getGroupId()).append(':');
// sb.append(getArtifactId()).append(':');
// sb.append(getType() == null ? "" : getType()).append(':');
// sb.append(getClassifier() == null ? "" : getClassifier()).append(
// ':');
// sb.append(getVersion() == null ? "" : getVersion());
// sb.append("!/");
// sb.append(getResource());
// return sb.toString();
// }
// }
//
// public static DependencyResource valueOf(String value)
// throws IllegalArgumentException {
//
// final String resourceDelimiter = "!/";
// final int resourceDelimiterPosition = value.indexOf(resourceDelimiter);
//
// final String dependencyPart;
// final String resource;
// if (resourceDelimiterPosition == -1) {
// dependencyPart = value;
// resource = "";
// } else {
// dependencyPart = value.substring(0, resourceDelimiterPosition);
// resource = value.substring(resourceDelimiterPosition
// + resourceDelimiter.length());
// }
//
// final String[] dependencyParts = StringUtils.split(dependencyPart, ':',
// true);
//
// if (dependencyParts.length < 2) {
// throw new IllegalArgumentException(
// MessageFormat
// .format("Error parsing dependency descriptor [{0}], both groupId and artifactId must be specified.",
// dependencyPart));
// }
//
// if (dependencyParts.length > 5) {
// throw new IllegalArgumentException(
// MessageFormat
// .format("Error parsing dependency descriptor [{0}], it contains too many parts.",
// dependencyPart));
// }
//
// final String groupId = dependencyParts[0];
// final String artifactId = dependencyParts[1];
// final String version;
//
// final String type;
//
// if (dependencyParts.length > 2) {
// type = (dependencyParts[2] == null || dependencyParts[2].length() == 0) ? null
// : dependencyParts[2];
// } else {
// type = null;
// }
//
// final String classifier;
//
// if (dependencyParts.length > 3) {
// classifier = (dependencyParts[3] == null || dependencyParts[3]
// .length() == 0) ? null : dependencyParts[3];
// } else {
// classifier = null;
// }
//
// if (dependencyParts.length > 4) {
// version = (dependencyParts[4] == null || dependencyParts[4]
// .length() == 0) ? null : dependencyParts[4];
// } else {
// version = null;
// }
//
// final DependencyResource dependencyResource = new DependencyResource();
//
// dependencyResource.setGroupId(groupId);
// dependencyResource.setArtifactId(artifactId);
// if (version != null) {
// dependencyResource.setVersion(version);
// }
// if (type != null) {
// dependencyResource.setType(type);
// }
// if (classifier != null) {
// dependencyResource.setClassifier(classifier);
// }
// if (resource != null) {
// dependencyResource.setResource(resource);
// }
// dependencyResource.setSystemId(value);
// return dependencyResource;
// }
// }
// Path: plugin-core/src/test/java/org/jvnet/jaxb2/maven2/tests/DependencyResourceTest.java
import org.junit.Test;
import org.jvnet.jaxb2.maven2.DependencyResource;
package org.jvnet.jaxb2.maven2.tests;
public class DependencyResourceTest {
@Test
public void correctlyParsesDepenencyResource() {
{
@SuppressWarnings("unused")
|
DependencyResource dependencyResource = DependencyResource
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/test/java/org/jvnet/jaxb2/maven2/util/tests/CollectionsUtilsTests.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public class CollectionUtils {
//
// public static class PositiveComparatorWithNullAsGreatest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return o1.compareTo(o2);
// }
// }
//
// public static class NegativeComparatorWithNullAsSmallest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return -o1.compareTo(o2);
// }
// }
//
// public interface Function<T, V> {
// public V eval(T argument);
// }
//
// public static <T, V> List<V> apply(Collection<T> collection,
// Function<T, V> function) {
// final List<V> list = new ArrayList<V>(collection.size());
// for (T t : collection) {
// list.add(function.eval(t));
// }
// return list;
// }
//
// public static <T, V> V bestValue(Collection<T> collection,
// CollectionUtils.Function<T, V> function, Comparator<V> comparator) {
//
// if (collection == null || collection.isEmpty())
// return null;
//
// final Iterator<T> i = collection.iterator();
// V candidateValue = function.eval(i.next());
//
// while (i.hasNext()) {
// final V nextValue = function.eval(i.next());
// if (comparator.compare(candidateValue, nextValue) < 0) {
// candidateValue = nextValue;
// }
// }
// return candidateValue;
// }
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> LT_NULL_SMALLEST = new NegativeComparatorWithNullAsSmallest();
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> GT_NULL_GREATEST = new PositiveComparatorWithNullAsGreatest();
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> ltWithNullAsSmallest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) LT_NULL_SMALLEST;
// return comparator;
// }
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> gtWithNullAsGreatest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) GT_NULL_GREATEST;
// return comparator;
// }
//
// }
//
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
|
import java.util.Arrays;
import java.util.Comparator;
import junit.framework.Assert;
import org.junit.Test;
import org.jvnet.jaxb2.maven2.util.CollectionUtils;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
|
package org.jvnet.jaxb2.maven2.util.tests;
public class CollectionsUtilsTests {
@Test
public void correctlyCompares() {
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public class CollectionUtils {
//
// public static class PositiveComparatorWithNullAsGreatest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return o1.compareTo(o2);
// }
// }
//
// public static class NegativeComparatorWithNullAsSmallest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return -o1.compareTo(o2);
// }
// }
//
// public interface Function<T, V> {
// public V eval(T argument);
// }
//
// public static <T, V> List<V> apply(Collection<T> collection,
// Function<T, V> function) {
// final List<V> list = new ArrayList<V>(collection.size());
// for (T t : collection) {
// list.add(function.eval(t));
// }
// return list;
// }
//
// public static <T, V> V bestValue(Collection<T> collection,
// CollectionUtils.Function<T, V> function, Comparator<V> comparator) {
//
// if (collection == null || collection.isEmpty())
// return null;
//
// final Iterator<T> i = collection.iterator();
// V candidateValue = function.eval(i.next());
//
// while (i.hasNext()) {
// final V nextValue = function.eval(i.next());
// if (comparator.compare(candidateValue, nextValue) < 0) {
// candidateValue = nextValue;
// }
// }
// return candidateValue;
// }
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> LT_NULL_SMALLEST = new NegativeComparatorWithNullAsSmallest();
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> GT_NULL_GREATEST = new PositiveComparatorWithNullAsGreatest();
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> ltWithNullAsSmallest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) LT_NULL_SMALLEST;
// return comparator;
// }
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> gtWithNullAsGreatest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) GT_NULL_GREATEST;
// return comparator;
// }
//
// }
//
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
// Path: plugin-core/src/test/java/org/jvnet/jaxb2/maven2/util/tests/CollectionsUtilsTests.java
import java.util.Arrays;
import java.util.Comparator;
import junit.framework.Assert;
import org.junit.Test;
import org.jvnet.jaxb2.maven2.util.CollectionUtils;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
package org.jvnet.jaxb2.maven2.util.tests;
public class CollectionsUtilsTests {
@Test
public void correctlyCompares() {
|
final Function<String, String> identity = new Function<String, String>() {
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/test/java/org/jvnet/jaxb2/maven2/util/tests/CollectionsUtilsTests.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public class CollectionUtils {
//
// public static class PositiveComparatorWithNullAsGreatest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return o1.compareTo(o2);
// }
// }
//
// public static class NegativeComparatorWithNullAsSmallest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return -o1.compareTo(o2);
// }
// }
//
// public interface Function<T, V> {
// public V eval(T argument);
// }
//
// public static <T, V> List<V> apply(Collection<T> collection,
// Function<T, V> function) {
// final List<V> list = new ArrayList<V>(collection.size());
// for (T t : collection) {
// list.add(function.eval(t));
// }
// return list;
// }
//
// public static <T, V> V bestValue(Collection<T> collection,
// CollectionUtils.Function<T, V> function, Comparator<V> comparator) {
//
// if (collection == null || collection.isEmpty())
// return null;
//
// final Iterator<T> i = collection.iterator();
// V candidateValue = function.eval(i.next());
//
// while (i.hasNext()) {
// final V nextValue = function.eval(i.next());
// if (comparator.compare(candidateValue, nextValue) < 0) {
// candidateValue = nextValue;
// }
// }
// return candidateValue;
// }
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> LT_NULL_SMALLEST = new NegativeComparatorWithNullAsSmallest();
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> GT_NULL_GREATEST = new PositiveComparatorWithNullAsGreatest();
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> ltWithNullAsSmallest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) LT_NULL_SMALLEST;
// return comparator;
// }
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> gtWithNullAsGreatest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) GT_NULL_GREATEST;
// return comparator;
// }
//
// }
//
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
|
import java.util.Arrays;
import java.util.Comparator;
import junit.framework.Assert;
import org.junit.Test;
import org.jvnet.jaxb2.maven2.util.CollectionUtils;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
|
package org.jvnet.jaxb2.maven2.util.tests;
public class CollectionsUtilsTests {
@Test
public void correctlyCompares() {
final Function<String, String> identity = new Function<String, String>() {
@Override
public String eval(String argument) {
return argument;
}
};
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public class CollectionUtils {
//
// public static class PositiveComparatorWithNullAsGreatest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return o1.compareTo(o2);
// }
// }
//
// public static class NegativeComparatorWithNullAsSmallest<V extends Object & Comparable<? super V>>
// implements Comparator<V> {
// public int compare(V o1, V o2) {
// if (o1 == null && o2 == null)
// return 0;
// else if (o1 == null)
// return 1;
// else if (o2 == null)
// return -1;
// else
// return -o1.compareTo(o2);
// }
// }
//
// public interface Function<T, V> {
// public V eval(T argument);
// }
//
// public static <T, V> List<V> apply(Collection<T> collection,
// Function<T, V> function) {
// final List<V> list = new ArrayList<V>(collection.size());
// for (T t : collection) {
// list.add(function.eval(t));
// }
// return list;
// }
//
// public static <T, V> V bestValue(Collection<T> collection,
// CollectionUtils.Function<T, V> function, Comparator<V> comparator) {
//
// if (collection == null || collection.isEmpty())
// return null;
//
// final Iterator<T> i = collection.iterator();
// V candidateValue = function.eval(i.next());
//
// while (i.hasNext()) {
// final V nextValue = function.eval(i.next());
// if (comparator.compare(candidateValue, nextValue) < 0) {
// candidateValue = nextValue;
// }
// }
// return candidateValue;
// }
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> LT_NULL_SMALLEST = new NegativeComparatorWithNullAsSmallest();
//
// @SuppressWarnings("rawtypes")
// private static Comparator<?> GT_NULL_GREATEST = new PositiveComparatorWithNullAsGreatest();
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> ltWithNullAsSmallest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) LT_NULL_SMALLEST;
// return comparator;
// }
//
// public static <V extends Object & Comparable<? super V>> Comparator<V> gtWithNullAsGreatest() {
// @SuppressWarnings("unchecked")
// final Comparator<V> comparator = (Comparator<V>) GT_NULL_GREATEST;
// return comparator;
// }
//
// }
//
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
// Path: plugin-core/src/test/java/org/jvnet/jaxb2/maven2/util/tests/CollectionsUtilsTests.java
import java.util.Arrays;
import java.util.Comparator;
import junit.framework.Assert;
import org.junit.Test;
import org.jvnet.jaxb2.maven2.util.CollectionUtils;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
package org.jvnet.jaxb2.maven2.util.tests;
public class CollectionsUtilsTests {
@Test
public void correctlyCompares() {
final Function<String, String> identity = new Function<String, String>() {
@Override
public String eval(String argument) {
return argument;
}
};
|
final Comparator<String> gt = CollectionUtils
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/main/java/org/jvnet/jaxb2/maven2/net/CompositeURILastModifiedResolver.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/plugin/logging/NullLog.java
// public class NullLog implements Log {
//
// @Override
// public boolean isDebugEnabled() {
// return false;
// }
//
// @Override
// public void debug(CharSequence content) {
// }
//
// @Override
// public void debug(CharSequence content, Throwable error) {
// }
//
// @Override
// public void debug(Throwable error) {
// }
//
// @Override
// public boolean isInfoEnabled() {
// return false;
// }
//
// @Override
// public void info(CharSequence content) {
// }
//
// @Override
// public void info(CharSequence content, Throwable error) {
// }
//
// @Override
// public void info(Throwable error) {
// }
//
// @Override
// public boolean isWarnEnabled() {
// return false;
// }
//
// @Override
// public void warn(CharSequence content) {
// }
//
// @Override
// public void warn(CharSequence content, Throwable error) {
// }
//
// @Override
// public void warn(Throwable error) {
// }
//
// @Override
// public boolean isErrorEnabled() {
// return false;
// }
//
// @Override
// public void error(CharSequence content) {
// }
//
// @Override
// public void error(CharSequence content, Throwable error) {
// }
//
// @Override
// public void error(Throwable error) {
// }
//
// public static Log INSTANCE = new NullLog();
//
// }
|
import java.net.URI;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang3.Validate;
import org.apache.maven.plugin.logging.Log;
import org.jvnet.jaxb2.maven2.plugin.logging.NullLog;
|
package org.jvnet.jaxb2.maven2.net;
public class CompositeURILastModifiedResolver implements
URILastModifiedResolver {
private final Map<String, URILastModifiedResolver> resolvers = new HashMap<String, URILastModifiedResolver>(
10);
private final Log logger;
public CompositeURILastModifiedResolver(Log logger) {
this.logger = Validate.notNull(logger);
addResolvers(new FileURILastModifiedResolver(logger),
new JarURILastModifiedResolver(logger, this),
new HttpURILastModifiedResolver(logger),
new HttpsURILastModifiedResolver(logger));
}
public CompositeURILastModifiedResolver() {
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/plugin/logging/NullLog.java
// public class NullLog implements Log {
//
// @Override
// public boolean isDebugEnabled() {
// return false;
// }
//
// @Override
// public void debug(CharSequence content) {
// }
//
// @Override
// public void debug(CharSequence content, Throwable error) {
// }
//
// @Override
// public void debug(Throwable error) {
// }
//
// @Override
// public boolean isInfoEnabled() {
// return false;
// }
//
// @Override
// public void info(CharSequence content) {
// }
//
// @Override
// public void info(CharSequence content, Throwable error) {
// }
//
// @Override
// public void info(Throwable error) {
// }
//
// @Override
// public boolean isWarnEnabled() {
// return false;
// }
//
// @Override
// public void warn(CharSequence content) {
// }
//
// @Override
// public void warn(CharSequence content, Throwable error) {
// }
//
// @Override
// public void warn(Throwable error) {
// }
//
// @Override
// public boolean isErrorEnabled() {
// return false;
// }
//
// @Override
// public void error(CharSequence content) {
// }
//
// @Override
// public void error(CharSequence content, Throwable error) {
// }
//
// @Override
// public void error(Throwable error) {
// }
//
// public static Log INSTANCE = new NullLog();
//
// }
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/net/CompositeURILastModifiedResolver.java
import java.net.URI;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang3.Validate;
import org.apache.maven.plugin.logging.Log;
import org.jvnet.jaxb2.maven2.plugin.logging.NullLog;
package org.jvnet.jaxb2.maven2.net;
public class CompositeURILastModifiedResolver implements
URILastModifiedResolver {
private final Map<String, URILastModifiedResolver> resolvers = new HashMap<String, URILastModifiedResolver>(
10);
private final Log logger;
public CompositeURILastModifiedResolver(Log logger) {
this.logger = Validate.notNull(logger);
addResolvers(new FileURILastModifiedResolver(logger),
new JarURILastModifiedResolver(logger, this),
new HttpURILastModifiedResolver(logger),
new HttpsURILastModifiedResolver(logger));
}
public CompositeURILastModifiedResolver() {
|
this(NullLog.INSTANCE);
|
highsource/maven-jaxb2-plugin
|
plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/ArtifactUtils.java
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
|
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.model.Dependency;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.artifact.InvalidDependencyVersionException;
import org.apache.maven.project.artifact.MavenMetadataSource;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
|
return resolvedArtifacts;
}
public static Collection<Artifact> resolve(
final ArtifactFactory artifactFactory,
final ArtifactResolver artifactResolver,
final ArtifactRepository localRepository,
final ArtifactMetadataSource artifactMetadataSource,
final Dependency[] dependencies, final MavenProject project)
throws InvalidDependencyVersionException,
ArtifactResolutionException, ArtifactNotFoundException {
if (dependencies == null) {
return Collections.emptyList();
}
@SuppressWarnings("unchecked")
final Set<Artifact> artifacts = MavenMetadataSource.createArtifacts(
artifactFactory, Arrays.asList(dependencies), "runtime", null,
project);
for (Artifact artifact : artifacts) {
artifactResolver.resolve(artifact,
project.getRemoteArtifactRepositories(), localRepository);
}
final Set<Artifact> resolvedArtifacts = artifacts;
return resolvedArtifacts;
}
|
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/CollectionUtils.java
// public interface Function<T, V> {
// public V eval(T argument);
// }
// Path: plugin-core/src/main/java/org/jvnet/jaxb2/maven2/util/ArtifactUtils.java
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.model.Dependency;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.artifact.InvalidDependencyVersionException;
import org.apache.maven.project.artifact.MavenMetadataSource;
import org.jvnet.jaxb2.maven2.util.CollectionUtils.Function;
return resolvedArtifacts;
}
public static Collection<Artifact> resolve(
final ArtifactFactory artifactFactory,
final ArtifactResolver artifactResolver,
final ArtifactRepository localRepository,
final ArtifactMetadataSource artifactMetadataSource,
final Dependency[] dependencies, final MavenProject project)
throws InvalidDependencyVersionException,
ArtifactResolutionException, ArtifactNotFoundException {
if (dependencies == null) {
return Collections.emptyList();
}
@SuppressWarnings("unchecked")
final Set<Artifact> artifacts = MavenMetadataSource.createArtifacts(
artifactFactory, Arrays.asList(dependencies), "runtime", null,
project);
for (Artifact artifact : artifacts) {
artifactResolver.resolve(artifact,
project.getRemoteArtifactRepositories(), localRepository);
}
final Set<Artifact> resolvedArtifacts = artifacts;
return resolvedArtifacts;
}
|
public static final Function<Artifact, File> GET_FILE = new Function<Artifact, File>() {
|
Pablissimo/SonarTsPlugin
|
src/main/java/com/pablissimo/sonar/TsRulesDefinition.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
|
import com.pablissimo.sonar.model.TsLintRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.debt.DebtRemediationFunction;
import org.sonar.api.server.rule.RulesDefinition;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;
|
package com.pablissimo.sonar;
public class TsRulesDefinition implements RulesDefinition {
private static final Logger LOG = LoggerFactory.getLogger(TsRulesDefinition.class);
public static final String REPOSITORY_NAME = "tslint";
public static final String DEFAULT_RULE_SEVERITY = Severity.defaultSeverity();
public static final String DEFAULT_RULE_DESCRIPTION = "No description provided for this TsLint rule";
public static final String DEFAULT_RULE_DEBT_SCALAR = "0min";
public static final String DEFAULT_RULE_DEBT_OFFSET = "0min";
public static final String DEFAULT_RULE_DEBT_TYPE = RuleType.CODE_SMELL.name();
private static final String CORE_RULES_CONFIG_RESOURCE_PATH = "/tslint/tslint-rules.properties";
/** The SonarQube rule that will contain all unknown TsLint issues. */
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
// Path: src/main/java/com/pablissimo/sonar/TsRulesDefinition.java
import com.pablissimo.sonar.model.TsLintRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.debt.DebtRemediationFunction;
import org.sonar.api.server.rule.RulesDefinition;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;
package com.pablissimo.sonar;
public class TsRulesDefinition implements RulesDefinition {
private static final Logger LOG = LoggerFactory.getLogger(TsRulesDefinition.class);
public static final String REPOSITORY_NAME = "tslint";
public static final String DEFAULT_RULE_SEVERITY = Severity.defaultSeverity();
public static final String DEFAULT_RULE_DESCRIPTION = "No description provided for this TsLint rule";
public static final String DEFAULT_RULE_DEBT_SCALAR = "0min";
public static final String DEFAULT_RULE_DEBT_OFFSET = "0min";
public static final String DEFAULT_RULE_DEBT_TYPE = RuleType.CODE_SMELL.name();
private static final String CORE_RULES_CONFIG_RESOURCE_PATH = "/tslint/tslint-rules.properties";
/** The SonarQube rule that will contain all unknown TsLint issues. */
|
public static final TsLintRule TSLINT_UNKNOWN_RULE = new TsLintRule(
|
Pablissimo/SonarTsPlugin
|
src/test/java/com/pablissimo/sonar/TsLintParserTest.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
|
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.pablissimo.sonar.model.TsLintIssue;
|
package com.pablissimo.sonar;
public class TsLintParserTest {
@Test
public void parsesValidTsLintRecordIntoObject() {
String parseRow1 = "[{\"endPosition\":{\"character\":44,\"line\":23,\"position\":658},\"failure\":\"for statements must be braced\",\"name\":\"Tools.ts\",\"ruleName\":\"curly\",\"startPosition\":{\"character\":6,\"line\":22,\"position\":587}}]";
List<String> toParse = new ArrayList<String>();
toParse.add(parseRow1);
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
// Path: src/test/java/com/pablissimo/sonar/TsLintParserTest.java
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.pablissimo.sonar.model.TsLintIssue;
package com.pablissimo.sonar;
public class TsLintParserTest {
@Test
public void parsesValidTsLintRecordIntoObject() {
String parseRow1 = "[{\"endPosition\":{\"character\":44,\"line\":23,\"position\":658},\"failure\":\"for statements must be braced\",\"name\":\"Tools.ts\",\"ruleName\":\"curly\",\"startPosition\":{\"character\":6,\"line\":22,\"position\":587}}]";
List<String> toParse = new ArrayList<String>();
toParse.add(parseRow1);
|
Map<String, List<TsLintIssue>> issues = new TsLintParserImpl().parse(toParse);
|
Pablissimo/SonarTsPlugin
|
src/main/java/com/pablissimo/sonar/TsLintParser.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
|
import java.util.List;
import java.util.Map;
import com.pablissimo.sonar.model.TsLintIssue;
|
package com.pablissimo.sonar;
@FunctionalInterface
public interface TsLintParser {
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
// Path: src/main/java/com/pablissimo/sonar/TsLintParser.java
import java.util.List;
import java.util.Map;
import com.pablissimo.sonar.model.TsLintIssue;
package com.pablissimo.sonar;
@FunctionalInterface
public interface TsLintParser {
|
Map<String, List<TsLintIssue>> parse(List<String> rawOutputBatches);
|
Pablissimo/SonarTsPlugin
|
src/main/java/com/pablissimo/sonar/TypeScriptRuleProfile.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
|
import com.pablissimo.sonar.model.TsLintRule;
import org.sonar.api.profiles.ProfileDefinition;
import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.rules.Rule;
import org.sonar.api.utils.ValidationMessages;
|
package com.pablissimo.sonar;
public class TypeScriptRuleProfile extends ProfileDefinition {
public static final String PROFILE_NAME = "tslint";
@Override
public RulesProfile createProfile(ValidationMessages validation) {
RulesProfile profile = RulesProfile.create("TsLint", TypeScriptLanguage.LANGUAGE_KEY);
TsRulesDefinition rules = new TsRulesDefinition();
activateRule(profile, TsRulesDefinition.TSLINT_UNKNOWN_RULE.key);
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
// Path: src/main/java/com/pablissimo/sonar/TypeScriptRuleProfile.java
import com.pablissimo.sonar.model.TsLintRule;
import org.sonar.api.profiles.ProfileDefinition;
import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.rules.Rule;
import org.sonar.api.utils.ValidationMessages;
package com.pablissimo.sonar;
public class TypeScriptRuleProfile extends ProfileDefinition {
public static final String PROFILE_NAME = "tslint";
@Override
public RulesProfile createProfile(ValidationMessages validation) {
RulesProfile profile = RulesProfile.create("TsLint", TypeScriptLanguage.LANGUAGE_KEY);
TsRulesDefinition rules = new TsRulesDefinition();
activateRule(profile, TsRulesDefinition.TSLINT_UNKNOWN_RULE.key);
|
for (TsLintRule coreRule : rules.getCoreRules()) {
|
Pablissimo/SonarTsPlugin
|
src/test/java/com/pablissimo/sonar/TsRulesDefinitionTest.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
|
import com.pablissimo.sonar.model.TsLintRule;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.debt.DebtRemediationFunction;
import org.sonar.api.server.rule.RulesDefinition.Context;
import org.sonar.api.server.rule.RulesDefinition.Rule;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.*;
|
assertEquals(RuleType.CODE_SMELL, rule3.type());
// cfg4
Rule rule4 = getRule("custom-rule-4");
assertNotNull(rule4);
assertEquals("test rule #4", rule4.name());
assertEquals(Severity.MINOR, rule4.severity());
assertEquals("#4 description", rule4.htmlDescription());
assertEquals(
DebtRemediationFunction.Type.LINEAR,
rule4.debtRemediationFunction().type()
);
assertEquals("5min", rule4.debtRemediationFunction().gapMultiplier());
assertEquals(null, rule4.debtRemediationFunction().baseEffort());
assertEquals(RuleType.BUG, rule4.type());
// cfg5
Rule rule5 = getRule("custom-rule-5");
assertNotNull(rule5);
assertEquals("test rule #5", rule5.name());
assertEquals(Severity.MAJOR, rule5.severity());
assertEquals("#5 description", rule5.htmlDescription());
assertEquals(RuleType.VULNERABILITY, rule5.type());
assertEquals("30min", rule5.debtRemediationFunction().gapMultiplier());
assertEquals("15min", rule5.debtRemediationFunction().baseEffort());
}
@Test
public void LoadRulesFromInvalidStream() throws IOException {
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintRule.java
// public class TsLintRule {
// public final String key;
// public final String name;
// public final String severity;
// public final String htmlDescription;
//
// public final boolean hasDebtRemediation;
// public final DebtRemediationFunction.Type debtRemediationFunction;
// public final String debtRemediationScalar;
// public final String debtRemediationOffset;
// public final String debtType;
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = false;
// this.debtRemediationFunction = DebtRemediationFunction.Type.CONSTANT_ISSUE;
// this.debtRemediationScalar = "0min";
// this.debtRemediationOffset = "0min";
// this.debtType = null;
// }
//
// public TsLintRule(
// String key,
// String severity,
// String name,
// String htmlDescription,
// DebtRemediationFunction.Type debtRemediationFunction,
// String debtRemediationScalar,
// String debtRemediationOffset,
// String debtType
// ) {
// this.key = key;
// this.severity = severity;
// this.name = name;
// this.htmlDescription = htmlDescription;
//
// this.hasDebtRemediation = true;
// this.debtRemediationFunction = debtRemediationFunction;
// this.debtRemediationScalar = debtRemediationScalar;
// this.debtRemediationOffset = debtRemediationOffset;
// this.debtType = debtType;
// }
// }
// Path: src/test/java/com/pablissimo/sonar/TsRulesDefinitionTest.java
import com.pablissimo.sonar.model.TsLintRule;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.debt.DebtRemediationFunction;
import org.sonar.api.server.rule.RulesDefinition.Context;
import org.sonar.api.server.rule.RulesDefinition.Rule;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.*;
assertEquals(RuleType.CODE_SMELL, rule3.type());
// cfg4
Rule rule4 = getRule("custom-rule-4");
assertNotNull(rule4);
assertEquals("test rule #4", rule4.name());
assertEquals(Severity.MINOR, rule4.severity());
assertEquals("#4 description", rule4.htmlDescription());
assertEquals(
DebtRemediationFunction.Type.LINEAR,
rule4.debtRemediationFunction().type()
);
assertEquals("5min", rule4.debtRemediationFunction().gapMultiplier());
assertEquals(null, rule4.debtRemediationFunction().baseEffort());
assertEquals(RuleType.BUG, rule4.type());
// cfg5
Rule rule5 = getRule("custom-rule-5");
assertNotNull(rule5);
assertEquals("test rule #5", rule5.name());
assertEquals(Severity.MAJOR, rule5.severity());
assertEquals("#5 description", rule5.htmlDescription());
assertEquals(RuleType.VULNERABILITY, rule5.type());
assertEquals("30min", rule5.debtRemediationFunction().gapMultiplier());
assertEquals("15min", rule5.debtRemediationFunction().baseEffort());
}
@Test
public void LoadRulesFromInvalidStream() throws IOException {
|
List<TsLintRule> rules = new ArrayList<>();
|
Pablissimo/SonarTsPlugin
|
src/test/java/com/pablissimo/sonar/TsLintSensorTest.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
//
// Path: src/main/java/com/pablissimo/sonar/model/TsLintPosition.java
// public class TsLintPosition {
// private int position;
// private int line;
// private int character;
//
// public int getPosition() {
// return position;
// }
//
// public void setPosition(int position) {
// this.position = position;
// }
//
// public int getLine() {
// return line;
// }
//
// public void setLine(int line) {
// this.line = line;
// }
//
// public int getCharacter() {
// return character;
// }
//
// public void setCharacter(int character) {
// this.character = character;
// }
// }
|
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
import org.sonar.api.batch.sensor.internal.SensorContextTester;
import org.sonar.api.config.Settings;
import com.pablissimo.sonar.model.TsLintIssue;
import com.pablissimo.sonar.model.TsLintPosition;
import org.sonar.api.rule.RuleKey;
|
Answer<String> lookUpFakePath = new Answer<String>() {
@Override
public String answer(InvocationOnMock invocation) throws Throwable {
return fakePathResolutions.get(invocation.<String>getArgument(1));
}
};
doAnswer(lookUpFakePath).when(this.resolver).getPath(any(SensorContext.class), any(String.class), (String) any());
this.configCaptor = ArgumentCaptor.forClass(TsLintExecutorConfig.class);
}
@Test
public void describe_setsName() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertNotNull(desc.name());
}
@Test
public void describe_setsLanguage() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertEquals(TypeScriptLanguage.LANGUAGE_KEY, desc.languages().iterator().next());
}
@Test
public void execute_addsIssues() {
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
//
// Path: src/main/java/com/pablissimo/sonar/model/TsLintPosition.java
// public class TsLintPosition {
// private int position;
// private int line;
// private int character;
//
// public int getPosition() {
// return position;
// }
//
// public void setPosition(int position) {
// this.position = position;
// }
//
// public int getLine() {
// return line;
// }
//
// public void setLine(int line) {
// this.line = line;
// }
//
// public int getCharacter() {
// return character;
// }
//
// public void setCharacter(int character) {
// this.character = character;
// }
// }
// Path: src/test/java/com/pablissimo/sonar/TsLintSensorTest.java
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
import org.sonar.api.batch.sensor.internal.SensorContextTester;
import org.sonar.api.config.Settings;
import com.pablissimo.sonar.model.TsLintIssue;
import com.pablissimo.sonar.model.TsLintPosition;
import org.sonar.api.rule.RuleKey;
Answer<String> lookUpFakePath = new Answer<String>() {
@Override
public String answer(InvocationOnMock invocation) throws Throwable {
return fakePathResolutions.get(invocation.<String>getArgument(1));
}
};
doAnswer(lookUpFakePath).when(this.resolver).getPath(any(SensorContext.class), any(String.class), (String) any());
this.configCaptor = ArgumentCaptor.forClass(TsLintExecutorConfig.class);
}
@Test
public void describe_setsName() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertNotNull(desc.name());
}
@Test
public void describe_setsLanguage() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertEquals(TypeScriptLanguage.LANGUAGE_KEY, desc.languages().iterator().next());
}
@Test
public void execute_addsIssues() {
|
TsLintIssue issue = new TsLintIssue();
|
Pablissimo/SonarTsPlugin
|
src/test/java/com/pablissimo/sonar/TsLintSensorTest.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
//
// Path: src/main/java/com/pablissimo/sonar/model/TsLintPosition.java
// public class TsLintPosition {
// private int position;
// private int line;
// private int character;
//
// public int getPosition() {
// return position;
// }
//
// public void setPosition(int position) {
// this.position = position;
// }
//
// public int getLine() {
// return line;
// }
//
// public void setLine(int line) {
// this.line = line;
// }
//
// public int getCharacter() {
// return character;
// }
//
// public void setCharacter(int character) {
// this.character = character;
// }
// }
|
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
import org.sonar.api.batch.sensor.internal.SensorContextTester;
import org.sonar.api.config.Settings;
import com.pablissimo.sonar.model.TsLintIssue;
import com.pablissimo.sonar.model.TsLintPosition;
import org.sonar.api.rule.RuleKey;
|
};
doAnswer(lookUpFakePath).when(this.resolver).getPath(any(SensorContext.class), any(String.class), (String) any());
this.configCaptor = ArgumentCaptor.forClass(TsLintExecutorConfig.class);
}
@Test
public void describe_setsName() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertNotNull(desc.name());
}
@Test
public void describe_setsLanguage() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertEquals(TypeScriptLanguage.LANGUAGE_KEY, desc.languages().iterator().next());
}
@Test
public void execute_addsIssues() {
TsLintIssue issue = new TsLintIssue();
issue.setFailure("failure");
issue.setRuleName("rule name");
issue.setName(this.file.absolutePath().replace("\\", "/"));
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
//
// Path: src/main/java/com/pablissimo/sonar/model/TsLintPosition.java
// public class TsLintPosition {
// private int position;
// private int line;
// private int character;
//
// public int getPosition() {
// return position;
// }
//
// public void setPosition(int position) {
// this.position = position;
// }
//
// public int getLine() {
// return line;
// }
//
// public void setLine(int line) {
// this.line = line;
// }
//
// public int getCharacter() {
// return character;
// }
//
// public void setCharacter(int character) {
// this.character = character;
// }
// }
// Path: src/test/java/com/pablissimo/sonar/TsLintSensorTest.java
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
import org.sonar.api.batch.sensor.internal.SensorContextTester;
import org.sonar.api.config.Settings;
import com.pablissimo.sonar.model.TsLintIssue;
import com.pablissimo.sonar.model.TsLintPosition;
import org.sonar.api.rule.RuleKey;
};
doAnswer(lookUpFakePath).when(this.resolver).getPath(any(SensorContext.class), any(String.class), (String) any());
this.configCaptor = ArgumentCaptor.forClass(TsLintExecutorConfig.class);
}
@Test
public void describe_setsName() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertNotNull(desc.name());
}
@Test
public void describe_setsLanguage() {
DefaultSensorDescriptor desc = new DefaultSensorDescriptor();
this.sensor.describe(desc);
assertEquals(TypeScriptLanguage.LANGUAGE_KEY, desc.languages().iterator().next());
}
@Test
public void execute_addsIssues() {
TsLintIssue issue = new TsLintIssue();
issue.setFailure("failure");
issue.setRuleName("rule name");
issue.setName(this.file.absolutePath().replace("\\", "/"));
|
TsLintPosition startPosition = new TsLintPosition();
|
Pablissimo/SonarTsPlugin
|
src/main/java/com/pablissimo/sonar/TsLintSensor.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
|
import com.pablissimo.sonar.model.TsLintIssue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.batch.fs.FileSystem;
import org.sonar.api.batch.rule.ActiveRule;
import org.sonar.api.batch.sensor.Sensor;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.SensorDescriptor;
import org.sonar.api.batch.sensor.issue.NewIssue;
import org.sonar.api.batch.sensor.issue.NewIssueLocation;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.RuleKey;
import java.io.File;
import java.io.IOException;
import java.util.*;
|
} else {
if (config.getConfigFile() == null && config.getPathToTsConfig() == null) {
LOG.warn("Path to tslint.json and tsconfig.json configuration files either not defined or not found - at least one is required. Skipping tslint analysis.");
return;
}
}
}
boolean skipTypeDefFiles = settings.getBoolean(TypeScriptPlugin.SETTING_EXCLUDE_TYPE_DEFINITION_FILES);
Collection<ActiveRule> allRules = ctx.activeRules().findByRepository(TsRulesDefinition.REPOSITORY_NAME);
HashSet<String> ruleNames = new HashSet<>();
for (ActiveRule rule : allRules) {
ruleNames.add(rule.ruleKey().rule());
}
FileSystem fs = ctx.fileSystem();
List<String> paths = new ArrayList<>();
for (InputFile file : fs.inputFiles(fs.predicates().hasLanguage(TypeScriptLanguage.LANGUAGE_KEY))) {
if (shouldSkipFile(file.file(), skipTypeDefFiles)) {
continue;
}
String pathAdjusted = file.absolutePath();
paths.add(pathAdjusted);
}
List<String> jsonResults = this.executor.execute(config, paths);
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
// Path: src/main/java/com/pablissimo/sonar/TsLintSensor.java
import com.pablissimo.sonar.model.TsLintIssue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.batch.fs.FileSystem;
import org.sonar.api.batch.rule.ActiveRule;
import org.sonar.api.batch.sensor.Sensor;
import org.sonar.api.batch.sensor.SensorContext;
import org.sonar.api.batch.sensor.SensorDescriptor;
import org.sonar.api.batch.sensor.issue.NewIssue;
import org.sonar.api.batch.sensor.issue.NewIssueLocation;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.config.Settings;
import org.sonar.api.rule.RuleKey;
import java.io.File;
import java.io.IOException;
import java.util.*;
} else {
if (config.getConfigFile() == null && config.getPathToTsConfig() == null) {
LOG.warn("Path to tslint.json and tsconfig.json configuration files either not defined or not found - at least one is required. Skipping tslint analysis.");
return;
}
}
}
boolean skipTypeDefFiles = settings.getBoolean(TypeScriptPlugin.SETTING_EXCLUDE_TYPE_DEFINITION_FILES);
Collection<ActiveRule> allRules = ctx.activeRules().findByRepository(TsRulesDefinition.REPOSITORY_NAME);
HashSet<String> ruleNames = new HashSet<>();
for (ActiveRule rule : allRules) {
ruleNames.add(rule.ruleKey().rule());
}
FileSystem fs = ctx.fileSystem();
List<String> paths = new ArrayList<>();
for (InputFile file : fs.inputFiles(fs.predicates().hasLanguage(TypeScriptLanguage.LANGUAGE_KEY))) {
if (shouldSkipFile(file.file(), skipTypeDefFiles)) {
continue;
}
String pathAdjusted = file.absolutePath();
paths.add(pathAdjusted);
}
List<String> jsonResults = this.executor.execute(config, paths);
|
Map<String, List<TsLintIssue>> issues = this.parser.parse(jsonResults);
|
Pablissimo/SonarTsPlugin
|
src/main/java/com/pablissimo/sonar/TsLintParserImpl.java
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
|
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.sonar.api.batch.BatchSide;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.pablissimo.sonar.model.TsLintIssue;
|
package com.pablissimo.sonar;
@BatchSide
public class TsLintParserImpl implements TsLintParser {
@Override
|
// Path: src/main/java/com/pablissimo/sonar/model/TsLintIssue.java
// public class TsLintIssue {
// private String name;
// private TsLintPosition startPosition;
// private TsLintPosition endPosition;
// private String failure;
// private String ruleName;
//
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public TsLintPosition getStartPosition() {
// return startPosition;
// }
//
// public void setStartPosition(TsLintPosition startPosition) {
// this.startPosition = startPosition;
// }
//
// public TsLintPosition getEndPosition() {
// return endPosition;
// }
//
// public void setEndPosition(TsLintPosition endPosition) {
// this.endPosition = endPosition;
// }
//
// public String getFailure() {
// return failure;
// }
//
// public void setFailure(String failure) {
// this.failure = failure;
// }
//
// public String getRuleName() {
// return ruleName;
// }
//
// public void setRuleName(String ruleName) {
// this.ruleName = ruleName;
// }
// }
// Path: src/main/java/com/pablissimo/sonar/TsLintParserImpl.java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.sonar.api.batch.BatchSide;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.pablissimo.sonar.model.TsLintIssue;
package com.pablissimo.sonar;
@BatchSide
public class TsLintParserImpl implements TsLintParser {
@Override
|
public Map<String, List<TsLintIssue>> parse(List<String> toParse) {
|
pyk/rojak
|
rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ApplicationComponent.java
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
// public class RojakBaseApplication extends Application {
// @Inject
// EventBus mEventBus;
// private Scheduler mScheduler;
// private ApplicationComponent mApplicationComponent;
//
// public static RojakBaseApplication get(Context context) {
// return (RojakBaseApplication) context.getApplicationContext();
// }
//
// @Override
// public void onCreate() {
// super.onCreate();
//
// boolean isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
//
// if (isDebuggable) {
// Timber.plant(new Timber.DebugTree());
// }
//
// mApplicationComponent = DaggerApplicationComponent.builder().applicationModule(new ApplicationModule(this)).build();
//
// mApplicationComponent.inject(this);
// mEventBus.register(this);
// }
//
// public ApplicationComponent getApplicationComponent() {
// return mApplicationComponent;
// }
//
// @VisibleForTesting
// public void setApplicationComponent(ApplicationComponent applicationComponent) {
// this.mApplicationComponent = applicationComponent;
// }
//
// public Scheduler getSubscribeScheduler() {
// if (mScheduler == null) {
// mScheduler = Schedulers.io();
// }
// return mScheduler;
// }
//
// @Override
// public void onLowMemory() {
// super.onLowMemory();
// Timber.e("########## onLowMemory ##########");
// }
//
// @Override
// public void onTerminate() {
// mEventBus.unregister(this);
// super.onTerminate();
// }
//
// @Subscribe
// public void onEvent(AuthenticationErrorEvent event) {
// Timber.e("Unauthorized! Redirect to Signin Activity..!.");
// }
//
// }
|
import android.content.Context;
import org.greenrobot.eventbus.EventBus;
import javax.inject.Singleton;
import dagger.Component;
import id.artificialintelligence.rojak.RojakBaseApplication;
import id.artificialintelligence.rojak.data.local.PreferencesHelper;
import id.artificialintelligence.rojak.data.remote.ApiService;
import id.artificialintelligence.rojak.data.remote.UnauthorisedInterceptor;
import id.artificialintelligence.rojak.di.module.ApplicationModule;
import id.artificialintelligence.rojak.di.module.NetworkModule;
|
package id.artificialintelligence.rojak.di.component;
@Singleton
@Component(modules = {
ApplicationModule.class,
NetworkModule.class
})
public interface ApplicationComponent {
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
// public class RojakBaseApplication extends Application {
// @Inject
// EventBus mEventBus;
// private Scheduler mScheduler;
// private ApplicationComponent mApplicationComponent;
//
// public static RojakBaseApplication get(Context context) {
// return (RojakBaseApplication) context.getApplicationContext();
// }
//
// @Override
// public void onCreate() {
// super.onCreate();
//
// boolean isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
//
// if (isDebuggable) {
// Timber.plant(new Timber.DebugTree());
// }
//
// mApplicationComponent = DaggerApplicationComponent.builder().applicationModule(new ApplicationModule(this)).build();
//
// mApplicationComponent.inject(this);
// mEventBus.register(this);
// }
//
// public ApplicationComponent getApplicationComponent() {
// return mApplicationComponent;
// }
//
// @VisibleForTesting
// public void setApplicationComponent(ApplicationComponent applicationComponent) {
// this.mApplicationComponent = applicationComponent;
// }
//
// public Scheduler getSubscribeScheduler() {
// if (mScheduler == null) {
// mScheduler = Schedulers.io();
// }
// return mScheduler;
// }
//
// @Override
// public void onLowMemory() {
// super.onLowMemory();
// Timber.e("########## onLowMemory ##########");
// }
//
// @Override
// public void onTerminate() {
// mEventBus.unregister(this);
// super.onTerminate();
// }
//
// @Subscribe
// public void onEvent(AuthenticationErrorEvent event) {
// Timber.e("Unauthorized! Redirect to Signin Activity..!.");
// }
//
// }
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ApplicationComponent.java
import android.content.Context;
import org.greenrobot.eventbus.EventBus;
import javax.inject.Singleton;
import dagger.Component;
import id.artificialintelligence.rojak.RojakBaseApplication;
import id.artificialintelligence.rojak.data.local.PreferencesHelper;
import id.artificialintelligence.rojak.data.remote.ApiService;
import id.artificialintelligence.rojak.data.remote.UnauthorisedInterceptor;
import id.artificialintelligence.rojak.di.module.ApplicationModule;
import id.artificialintelligence.rojak.di.module.NetworkModule;
package id.artificialintelligence.rojak.di.component;
@Singleton
@Component(modules = {
ApplicationModule.class,
NetworkModule.class
})
public interface ApplicationComponent {
|
void inject(RojakBaseApplication baseApplication);
|
pyk/rojak
|
rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ApplicationComponent.java
// @Singleton
// @Component(modules = {
// ApplicationModule.class,
// NetworkModule.class
// })
// public interface ApplicationComponent {
//
// void inject(RojakBaseApplication baseApplication);
//
// void inject(UnauthorisedInterceptor unauthorisedInterceptor);
//
// Context context();
//
// ApiService apiService();
//
// EventBus eventBus();
//
// PreferencesHelper prefsHelper();
//
// }
|
import android.app.Application;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.support.annotation.VisibleForTesting;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import javax.inject.Inject;
import id.artificialintelligence.rojak.di.component.ApplicationComponent;
import id.artificialintelligence.rojak.di.component.DaggerApplicationComponent;
import id.artificialintelligence.rojak.di.module.ApplicationModule;
import id.artificialintelligence.rojak.events.AuthenticationErrorEvent;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import timber.log.Timber;
|
package id.artificialintelligence.rojak;
public class RojakBaseApplication extends Application {
@Inject
EventBus mEventBus;
private Scheduler mScheduler;
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ApplicationComponent.java
// @Singleton
// @Component(modules = {
// ApplicationModule.class,
// NetworkModule.class
// })
// public interface ApplicationComponent {
//
// void inject(RojakBaseApplication baseApplication);
//
// void inject(UnauthorisedInterceptor unauthorisedInterceptor);
//
// Context context();
//
// ApiService apiService();
//
// EventBus eventBus();
//
// PreferencesHelper prefsHelper();
//
// }
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
import android.app.Application;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.support.annotation.VisibleForTesting;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import javax.inject.Inject;
import id.artificialintelligence.rojak.di.component.ApplicationComponent;
import id.artificialintelligence.rojak.di.component.DaggerApplicationComponent;
import id.artificialintelligence.rojak.di.module.ApplicationModule;
import id.artificialintelligence.rojak.events.AuthenticationErrorEvent;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import timber.log.Timber;
package id.artificialintelligence.rojak;
public class RojakBaseApplication extends Application {
@Inject
EventBus mEventBus;
private Scheduler mScheduler;
|
private ApplicationComponent mApplicationComponent;
|
pyk/rojak
|
rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ActivityComponent.java
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
// public class RojakBaseApplication extends Application {
// @Inject
// EventBus mEventBus;
// private Scheduler mScheduler;
// private ApplicationComponent mApplicationComponent;
//
// public static RojakBaseApplication get(Context context) {
// return (RojakBaseApplication) context.getApplicationContext();
// }
//
// @Override
// public void onCreate() {
// super.onCreate();
//
// boolean isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
//
// if (isDebuggable) {
// Timber.plant(new Timber.DebugTree());
// }
//
// mApplicationComponent = DaggerApplicationComponent.builder().applicationModule(new ApplicationModule(this)).build();
//
// mApplicationComponent.inject(this);
// mEventBus.register(this);
// }
//
// public ApplicationComponent getApplicationComponent() {
// return mApplicationComponent;
// }
//
// @VisibleForTesting
// public void setApplicationComponent(ApplicationComponent applicationComponent) {
// this.mApplicationComponent = applicationComponent;
// }
//
// public Scheduler getSubscribeScheduler() {
// if (mScheduler == null) {
// mScheduler = Schedulers.io();
// }
// return mScheduler;
// }
//
// @Override
// public void onLowMemory() {
// super.onLowMemory();
// Timber.e("########## onLowMemory ##########");
// }
//
// @Override
// public void onTerminate() {
// mEventBus.unregister(this);
// super.onTerminate();
// }
//
// @Subscribe
// public void onEvent(AuthenticationErrorEvent event) {
// Timber.e("Unauthorized! Redirect to Signin Activity..!.");
// }
//
// }
|
import id.artificialintelligence.rojak.RojakBaseApplication;
import id.artificialintelligence.rojak.di.ActivityScope;
import dagger.Component;
|
package id.artificialintelligence.rojak.di.component;
@ActivityScope
@Component(dependencies = ApplicationComponent.class)
public interface ActivityComponent extends ApplicationComponent {
|
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/RojakBaseApplication.java
// public class RojakBaseApplication extends Application {
// @Inject
// EventBus mEventBus;
// private Scheduler mScheduler;
// private ApplicationComponent mApplicationComponent;
//
// public static RojakBaseApplication get(Context context) {
// return (RojakBaseApplication) context.getApplicationContext();
// }
//
// @Override
// public void onCreate() {
// super.onCreate();
//
// boolean isDebuggable = (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE));
//
// if (isDebuggable) {
// Timber.plant(new Timber.DebugTree());
// }
//
// mApplicationComponent = DaggerApplicationComponent.builder().applicationModule(new ApplicationModule(this)).build();
//
// mApplicationComponent.inject(this);
// mEventBus.register(this);
// }
//
// public ApplicationComponent getApplicationComponent() {
// return mApplicationComponent;
// }
//
// @VisibleForTesting
// public void setApplicationComponent(ApplicationComponent applicationComponent) {
// this.mApplicationComponent = applicationComponent;
// }
//
// public Scheduler getSubscribeScheduler() {
// if (mScheduler == null) {
// mScheduler = Schedulers.io();
// }
// return mScheduler;
// }
//
// @Override
// public void onLowMemory() {
// super.onLowMemory();
// Timber.e("########## onLowMemory ##########");
// }
//
// @Override
// public void onTerminate() {
// mEventBus.unregister(this);
// super.onTerminate();
// }
//
// @Subscribe
// public void onEvent(AuthenticationErrorEvent event) {
// Timber.e("Unauthorized! Redirect to Signin Activity..!.");
// }
//
// }
// Path: rojak-ui-app/RojakAndroid/app/src/main/java/id/artificialintelligence/rojak/di/component/ActivityComponent.java
import id.artificialintelligence.rojak.RojakBaseApplication;
import id.artificialintelligence.rojak.di.ActivityScope;
import dagger.Component;
package id.artificialintelligence.rojak.di.component;
@ActivityScope
@Component(dependencies = ApplicationComponent.class)
public interface ActivityComponent extends ApplicationComponent {
|
void inject(RojakBaseApplication baseActivity);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/TutorialTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
|
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Welcome to LmdbJava!
*
* <p>
* This short tutorial will walk you through using LmdbJava step-by-step.
*
* <p>
* If you are using a 64-bit Windows, Linux or OS X machine, you can simply run
* this tutorial by adding the LmdbJava JAR to your classpath. It includes the
* required system libraries. If you are using another 64-bit platform, you'll
* need to install the LMDB system library yourself. 32-bit platforms are not
* supported.
*/
public final class TutorialTest {
private static final String DB_NAME = "my DB";
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
/**
* In this first tutorial we will use LmdbJava with some basic defaults.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial1() throws IOException {
// We need a storage directory first.
// The path cannot be on a remote file system.
final File path = tmp.newFolder();
// We always need an Env. An Env owns a physical on-disk storage file. One
// Env can store many different databases (ie sorted maps).
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
// Path: src/test/java/org/lmdbjava/TutorialTest.java
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Welcome to LmdbJava!
*
* <p>
* This short tutorial will walk you through using LmdbJava step-by-step.
*
* <p>
* If you are using a 64-bit Windows, Linux or OS X machine, you can simply run
* this tutorial by adding the LmdbJava JAR to your classpath. It includes the
* required system libraries. If you are using another 64-bit platform, you'll
* need to install the LMDB system library yourself. 32-bit platforms are not
* supported.
*/
public final class TutorialTest {
private static final String DB_NAME = "my DB";
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
/**
* In this first tutorial we will use LmdbJava with some basic defaults.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial1() throws IOException {
// We need a storage directory first.
// The path cannot be on a remote file system.
final File path = tmp.newFolder();
// We always need an Env. An Env owns a physical on-disk storage file. One
// Env can store many different databases (ie sorted maps).
|
final Env<ByteBuffer> env = create()
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/TutorialTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
|
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
|
/**
* In this fourth tutorial we'll take a quick look at the iterators. These are
* a more Java idiomatic form of using the Cursors we looked at in tutorial 3.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial4() throws IOException {
final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final ByteBuffer key = allocateDirect(env.getMaxKeySize());
final ByteBuffer val = allocateDirect(700);
// Insert some data. Note that ByteBuffer order defaults to Big Endian.
// LMDB does not persist the byte order, but it's critical to sort keys.
// If your numeric keys don't sort as expected, review buffer byte order.
val.putInt(100);
key.putInt(1);
db.put(txn, key, val);
key.clear();
key.putInt(2);
db.put(txn, key, val);
key.clear();
// Each iterable uses a cursor and must be closed when finished. Iterate
// forward in terms of key ordering starting with the first key.
try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
// Path: src/test/java/org/lmdbjava/TutorialTest.java
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
/**
* In this fourth tutorial we'll take a quick look at the iterators. These are
* a more Java idiomatic form of using the Cursors we looked at in tutorial 3.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial4() throws IOException {
final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final ByteBuffer key = allocateDirect(env.getMaxKeySize());
final ByteBuffer val = allocateDirect(700);
// Insert some data. Note that ByteBuffer order defaults to Big Endian.
// LMDB does not persist the byte order, but it's critical to sort keys.
// If your numeric keys don't sort as expected, review buffer byte order.
val.putInt(100);
key.putInt(1);
db.put(txn, key, val);
key.clear();
key.putInt(2);
db.put(txn, key, val);
key.clear();
// Each iterable uses a cursor and must be closed when finished. Iterate
// forward in terms of key ordering starting with the first key.
try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
|
for (final KeyVal<ByteBuffer> kv : ci) {
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/TutorialTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
|
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
|
assertThat(count, is(3L));
// Let's position the Cursor. Note sorting still works.
c.seek(MDB_FIRST);
assertThat(UTF_8.decode(c.val()).toString(), is("kkk"));
c.seek(MDB_LAST);
assertThat(UTF_8.decode(c.val()).toString(), is("xxx"));
c.seek(MDB_PREV);
assertThat(UTF_8.decode(c.val()).toString(), is("lll"));
c.close();
txn.commit();
}
env.close();
}
/**
* Next up we'll show you how to easily check your platform (operating system
* and Java version) is working properly with LmdbJava and the embedded LMDB
* native library.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial6() throws IOException {
// Note we need to specify the Verifier's DBI_COUNT for the Env.
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
// Path: src/test/java/org/lmdbjava/TutorialTest.java
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
assertThat(count, is(3L));
// Let's position the Cursor. Note sorting still works.
c.seek(MDB_FIRST);
assertThat(UTF_8.decode(c.val()).toString(), is("kkk"));
c.seek(MDB_LAST);
assertThat(UTF_8.decode(c.val()).toString(), is("xxx"));
c.seek(MDB_PREV);
assertThat(UTF_8.decode(c.val()).toString(), is("lll"));
c.close();
txn.commit();
}
env.close();
}
/**
* Next up we'll show you how to easily check your platform (operating system
* and Java version) is working properly with LmdbJava and the embedded LMDB
* native library.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial6() throws IOException {
// Note we need to specify the Verifier's DBI_COUNT for the Env.
|
final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/TutorialTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
|
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
|
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial6() throws IOException {
// Note we need to specify the Verifier's DBI_COUNT for the Env.
final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
.setMapSize(10_485_760)
.setMaxDbs(Verifier.DBI_COUNT)
.open(tmp.newFolder());
// Create a Verifier (it's a Callable<Long> for those needing full control).
final Verifier v = new Verifier(env);
// We now run the verifier for 3 seconds; it raises an exception on failure.
// The method returns the number of entries it successfully verified.
v.runFor(3, SECONDS);
env.close();
}
/**
* In this final tutorial we'll look at using Agrona's DirectBuffer.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial7() throws IOException {
// The critical difference is we pass the PROXY_DB field to Env.create().
// There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
// Aside from that and a different type argument, it's the same as usual...
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/CursorIterable.java
// public static final class KeyVal<T> {
//
// private T k;
// private T v;
//
// /**
// * The key.
// *
// * @return key
// */
// public T key() {
// return k;
// }
//
// /**
// * The value.
// *
// * @return value
// */
// public T val() {
// return v;
// }
//
// void setK(final T key) {
// this.k = key;
// }
//
// void setV(final T val) {
// this.v = val;
// }
//
// }
// Path: src/test/java/org/lmdbjava/TutorialTest.java
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.Executors.newCachedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.GetOp.MDB_SET;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_PREV;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.CursorIterable.KeyVal;
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial6() throws IOException {
// Note we need to specify the Verifier's DBI_COUNT for the Env.
final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
.setMapSize(10_485_760)
.setMaxDbs(Verifier.DBI_COUNT)
.open(tmp.newFolder());
// Create a Verifier (it's a Callable<Long> for those needing full control).
final Verifier v = new Verifier(env);
// We now run the verifier for 3 seconds; it raises an exception on failure.
// The method returns the number of entries it successfully verified.
v.runFor(3, SECONDS);
env.close();
}
/**
* In this final tutorial we'll look at using Agrona's DirectBuffer.
*
* @throws IOException if a path was unavailable for memory mapping
*/
@Test
@SuppressWarnings("ConvertToTryWithResources")
public void tutorial7() throws IOException {
// The critical difference is we pass the PROXY_DB field to Env.create().
// There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
// Aside from that and a different type argument, it's the same as usual...
|
final Env<DirectBuffer> env = create(PROXY_DB)
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/DirectBufferProxy.java
|
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
|
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.OneToOneConcurrentArrayQueue;
import org.agrona.concurrent.UnsafeBuffer;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import org.agrona.DirectBuffer;
|
return buffer;
} else {
final ByteBuffer bb = allocateDirect(0);
return new UnsafeBuffer(bb);
}
}
@Override
protected int compare(final DirectBuffer o1, final DirectBuffer o2) {
return compareBuff(o1, o2);
}
@Override
protected void deallocate(final DirectBuffer buff) {
final OneToOneConcurrentArrayQueue<DirectBuffer> q = BUFFERS.get();
q.offer(buff);
}
@Override
protected byte[] getBytes(final DirectBuffer buffer) {
final byte[] dest = new byte[buffer.capacity()];
buffer.getBytes(0, dest, 0, buffer.capacity());
return dest;
}
@Override
protected void in(final DirectBuffer buffer, final Pointer ptr,
final long ptrAddr) {
final long addr = buffer.addressOffset();
final long size = buffer.capacity();
|
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
import org.agrona.MutableDirectBuffer;
import org.agrona.concurrent.OneToOneConcurrentArrayQueue;
import org.agrona.concurrent.UnsafeBuffer;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import org.agrona.DirectBuffer;
return buffer;
} else {
final ByteBuffer bb = allocateDirect(0);
return new UnsafeBuffer(bb);
}
}
@Override
protected int compare(final DirectBuffer o1, final DirectBuffer o2) {
return compareBuff(o1, o2);
}
@Override
protected void deallocate(final DirectBuffer buff) {
final OneToOneConcurrentArrayQueue<DirectBuffer> q = BUFFERS.get();
q.offer(buff);
}
@Override
protected byte[] getBytes(final DirectBuffer buffer) {
final byte[] dest = new byte[buffer.capacity()];
buffer.getBytes(0, dest, 0, buffer.capacity());
return dest;
}
@Override
protected void in(final DirectBuffer buffer, final Pointer ptr,
final long ptrAddr) {
final long addr = buffer.addressOffset();
final long size = buffer.capacity();
|
UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MetaTest.java
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
// Path: src/test/java/org/lmdbjava/MetaTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
|
invokePrivateConstructor(Meta.class);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MetaTest.java
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
// Path: src/test/java/org/lmdbjava/MetaTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
|
assertThat(error(MDB_CORRUPTED), is(
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MetaTest.java
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
// Path: src/test/java/org/lmdbjava/MetaTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
|
assertThat(error(MDB_CORRUPTED), is(
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MetaTest.java
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
assertThat(error(MDB_CORRUPTED), is(
"MDB_CORRUPTED: Located page was wrong type"));
}
@Test
public void version() {
|
// Path: src/main/java/org/lmdbjava/LmdbNativeException.java
// static final int MDB_CORRUPTED = -30_796;
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static String error(final int err) {
// return LIB.mdb_strerror(err);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Meta.java
// public static final class Version {
//
// /**
// * LMDC native library major version number.
// */
// public final int major;
//
// /**
// * LMDC native library patch version number.
// */
// public final int minor;
//
// /**
// * LMDC native library patch version number.
// */
// public final int patch;
//
// Version(final int major, final int minor, final int patch) {
// this.major = major;
// this.minor = minor;
// this.patch = patch;
// }
// }
// Path: src/test/java/org/lmdbjava/MetaTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
import static org.lmdbjava.Meta.error;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Meta.Version;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Meta}.
*/
public final class MetaTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Meta.class);
}
@Test
public void errCode() {
assertThat(error(MDB_CORRUPTED), is(
"MDB_CORRUPTED: Located page was wrong type"));
}
@Test
public void version() {
|
final Version v = Meta.version();
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/LibraryTest.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
|
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
// Path: src/test/java/org/lmdbjava/LibraryTest.java
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
|
invokePrivateConstructor(Library.class);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/LibraryTest.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
|
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Library.class);
invokePrivateConstructor(UnsafeAccess.class);
}
@Test
public void structureFieldOrder() {
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
// Path: src/test/java/org/lmdbjava/LibraryTest.java
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Library.class);
invokePrivateConstructor(UnsafeAccess.class);
}
@Test
public void structureFieldOrder() {
|
final MDB_envinfo v = new MDB_envinfo(RUNTIME);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/LibraryTest.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
|
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Library.class);
invokePrivateConstructor(UnsafeAccess.class);
}
@Test
public void structureFieldOrder() {
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
// "checkstyle:MemberName"})
// public static final class MDB_envinfo extends Struct {
//
// public final Pointer f0_me_mapaddr;
// public final size_t f1_me_mapsize;
// public final size_t f2_me_last_pgno;
// public final size_t f3_me_last_txnid;
// public final u_int32_t f4_me_maxreaders;
// public final u_int32_t f5_me_numreaders;
//
// MDB_envinfo(final jnr.ffi.Runtime runtime) {
// super(runtime);
// this.f0_me_mapaddr = new Pointer();
// this.f1_me_mapsize = new size_t();
// this.f2_me_last_pgno = new size_t();
// this.f3_me_last_txnid = new size_t();
// this.f4_me_maxreaders = new u_int32_t();
// this.f5_me_numreaders = new u_int32_t();
// }
// }
// Path: src/test/java/org/lmdbjava/LibraryTest.java
import static java.lang.Long.BYTES;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import org.junit.Test;
import org.lmdbjava.Library.MDB_envinfo;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Library}.
*/
public final class LibraryTest {
@Test
public void coverPrivateConstructors() {
invokePrivateConstructor(Library.class);
invokePrivateConstructor(UnsafeAccess.class);
}
@Test
public void structureFieldOrder() {
|
final MDB_envinfo v = new MDB_envinfo(RUNTIME);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Meta.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
|
import jnr.ffi.byref.IntByReference;
import static org.lmdbjava.Library.LIB;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB metadata functions.
*/
public final class Meta {
private Meta() {
}
/**
* Fetches the LMDB error code description.
*
* <p>
* End users should not need this method, as LmdbJava converts all LMDB
* exceptions into a typed Java exception that incorporates the error code.
* However it is provided here for verification and troubleshooting (eg if the
* user wishes to see the original LMDB description of the error code, or
* there is a newer library version etc).
*
* @param err the error code returned from LMDB
* @return the description
*/
public static String error(final int err) {
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
// Path: src/main/java/org/lmdbjava/Meta.java
import jnr.ffi.byref.IntByReference;
import static org.lmdbjava.Library.LIB;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB metadata functions.
*/
public final class Meta {
private Meta() {
}
/**
* Fetches the LMDB error code description.
*
* <p>
* End users should not need this method, as LmdbJava converts all LMDB
* exceptions into a typed Java exception that incorporates the error code.
* However it is provided here for verification and troubleshooting (eg if the
* user wishes to see the original LMDB description of the error code, or
* there is a newer library version etc).
*
* @param err the error code returned from LMDB
* @return the description
*/
public static String error(final int err) {
|
return LIB.mdb_strerror(err);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/ByteBufProxy.java
|
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
|
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.lang.Class.forName;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import jnr.ffi.Pointer;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* A buffer proxy backed by Netty's {@link ByteBuf}.
*
* <p>
* This class requires {@link UnsafeAccess} and netty-buffer must be in the
* classpath.
*/
public final class ByteBufProxy extends BufferProxy<ByteBuf> {
/**
* A proxy for using Netty {@link ByteBuf}. Guaranteed to never be null,
* although a class initialization exception will occur if an attempt is made
* to access this field when Netty is unavailable.
*/
public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
private static final int BUFFER_RETRIES = 10;
private static final String FIELD_NAME_ADDRESS = "memoryAddress";
private static final String FIELD_NAME_LENGTH = "length";
private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
private final long lengthOffset;
private final long addressOffset;
private final PooledByteBufAllocator nettyAllocator;
private ByteBufProxy() {
this(DEFAULT);
}
public ByteBufProxy(final PooledByteBufAllocator allocator) {
this.nettyAllocator = allocator;
try {
final ByteBuf initBuf = this.allocate();
initBuf.release();
final Field address = findField(NAME, FIELD_NAME_ADDRESS);
final Field length = findField(NAME, FIELD_NAME_LENGTH);
|
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.lang.Class.forName;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import jnr.ffi.Pointer;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* A buffer proxy backed by Netty's {@link ByteBuf}.
*
* <p>
* This class requires {@link UnsafeAccess} and netty-buffer must be in the
* classpath.
*/
public final class ByteBufProxy extends BufferProxy<ByteBuf> {
/**
* A proxy for using Netty {@link ByteBuf}. Guaranteed to never be null,
* although a class initialization exception will occur if an attempt is made
* to access this field when Netty is unavailable.
*/
public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
private static final int BUFFER_RETRIES = 10;
private static final String FIELD_NAME_ADDRESS = "memoryAddress";
private static final String FIELD_NAME_LENGTH = "length";
private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
private final long lengthOffset;
private final long addressOffset;
private final PooledByteBufAllocator nettyAllocator;
private ByteBufProxy() {
this(DEFAULT);
}
public ByteBufProxy(final PooledByteBufAllocator allocator) {
this.nettyAllocator = allocator;
try {
final ByteBuf initBuf = this.allocate();
initBuf.release();
final Field address = findField(NAME, FIELD_NAME_ADDRESS);
final Field length = findField(NAME, FIELD_NAME_LENGTH);
|
addressOffset = UNSAFE.objectFieldOffset(address);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/VerifierTest.java
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
|
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.TimeUnit;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Verifier}.
*/
public final class VerifierTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test
public void verification() throws IOException {
final File path = tmp.newFile();
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
// Path: src/test/java/org/lmdbjava/VerifierTest.java
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.TimeUnit;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Verifier}.
*/
public final class VerifierTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test
public void verification() throws IOException {
final File path = tmp.newFile();
|
try (Env<ByteBuffer> env = create()
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/ByteArrayProxy.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
|
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Library.RUNTIME;
import java.util.Arrays;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Byte array proxy.
*
* {@link Env#create(org.lmdbjava.BufferProxy)}.
*/
public final class ByteArrayProxy extends BufferProxy<byte[]> {
/**
* The byte array proxy. Guaranteed to never be null.
*/
public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Library.RUNTIME;
import java.util.Arrays;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Byte array proxy.
*
* {@link Env#create(org.lmdbjava.BufferProxy)}.
*/
public final class ByteArrayProxy extends BufferProxy<byte[]> {
/**
* The byte array proxy. Guaranteed to never be null.
*/
public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
|
private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
|
env = create(PROXY_OPTIMAL)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
|
env = create(PROXY_OPTIMAL)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
|
.open(path, POSIX_MODE, MDB_NOSUBDIR);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
|
@Test(expected = ClosedException.class)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor}.
*/
public final class CursorTest {
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
private Env<ByteBuffer> env;
@After
public void after() {
env.close();
}
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
|
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final Cursor<ByteBuffer> c = db.openCursor(txn);
c.close();
c.seek(MDB_FIRST);
}
}
@Test
public void count() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
@Before
public void before() throws IOException {
try {
final File path = tmp.newFile();
env = create(PROXY_OPTIMAL)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
.open(path, POSIX_MODE, MDB_NOSUBDIR);
} catch (final IOException e) {
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final Cursor<ByteBuffer> c = db.openCursor(txn);
c.close();
c.seek(MDB_FIRST);
}
}
@Test
public void count() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
|
c.put(bb(1), bb(2), MDB_APPENDDUP);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final Cursor<ByteBuffer> c = db.openCursor(txn);
c.close();
c.seek(MDB_FIRST);
}
}
@Test
public void count() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
c.put(bb(1), bb(2), MDB_APPENDDUP);
assertThat(c.count(), is(1L));
c.put(bb(1), bb(4), MDB_APPENDDUP);
c.put(bb(1), bb(6), MDB_APPENDDUP);
assertThat(c.count(), is(3L));
c.put(bb(2), bb(1), MDB_APPENDDUP);
c.put(bb(2), bb(2), MDB_APPENDDUP);
assertThat(c.count(), is(2L));
}
}
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
throw new LmdbException("IO failure", e);
}
}
@Test(expected = ClosedException.class)
public void closedCursorRejectsSubsequentGets() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
try (Txn<ByteBuffer> txn = env.txnWrite()) {
final Cursor<ByteBuffer> c = db.openCursor(txn);
c.close();
c.seek(MDB_FIRST);
}
}
@Test
public void count() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
c.put(bb(1), bb(2), MDB_APPENDDUP);
assertThat(c.count(), is(1L));
c.put(bb(1), bb(4), MDB_APPENDDUP);
c.put(bb(1), bb(6), MDB_APPENDDUP);
assertThat(c.count(), is(3L));
c.put(bb(2), bb(1), MDB_APPENDDUP);
c.put(bb(2), bb(2), MDB_APPENDDUP);
assertThat(c.count(), is(2L));
}
}
|
@Test(expected = NotReadyException.class)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
|
}
}
@Test(expected = IllegalArgumentException.class)
public void putMultipleWithoutMdbMultipleFlag() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
c.putMultiple(bb(100), bb(1), 1);
}
}
@Test
public void renewTxRo() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final Cursor<ByteBuffer> c;
try (Txn<ByteBuffer> txn = env.txnRead()) {
c = db.openCursor(txn);
txn.commit();
}
try (Txn<ByteBuffer> txn = env.txnRead()) {
c.renew(txn);
txn.commit();
}
c.close();
}
|
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/main/java/org/lmdbjava/Cursor.java
// public static final class ClosedException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ClosedException() {
// super("Cursor has already been closed");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static final class NotReadyException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public NotReadyException() {
// super("Transaction is not in ready state");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Txn.java
// public static class ReadOnlyRequiredException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public ReadOnlyRequiredException() {
// super("Not a read-only transaction");
// }
// }
// Path: src/test/java/org/lmdbjava/CursorTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.lang.Long.MIN_VALUE;
import static java.nio.ByteBuffer.allocateDirect;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.Cursor.ClosedException;
import org.lmdbjava.Txn.NotReadyException;
import org.lmdbjava.Txn.ReadOnlyRequiredException;
}
}
@Test(expected = IllegalArgumentException.class)
public void putMultipleWithoutMdbMultipleFlag() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
try (Txn<ByteBuffer> txn = env.txnWrite();
Cursor<ByteBuffer> c = db.openCursor(txn)) {
c.putMultiple(bb(100), bb(1), 1);
}
}
@Test
public void renewTxRo() {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final Cursor<ByteBuffer> c;
try (Txn<ByteBuffer> txn = env.txnRead()) {
c = db.openCursor(txn);
txn.commit();
}
try (Txn<ByteBuffer> txn = env.txnRead()) {
c.renew(txn);
txn.commit();
}
c.close();
}
|
@Test(expected = ReadOnlyRequiredException.class)
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Txn.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Txn.java
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
|
final int flagsMask = mask(flags);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Txn.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Txn.java
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
|
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Txn.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Txn.java
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
|
final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Txn.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
final Pointer txnParentPtr = parent == null ? null : parent.ptr;
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Txn.java
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
final Pointer txnParentPtr = parent == null ? null : parent.ptr;
|
checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Txn.java
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
final Pointer txnParentPtr = parent == null ? null : parent.ptr;
|
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Txn.java
import static org.lmdbjava.Txn.State.RESET;
import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
import java.util.Comparator;
import jnr.ffi.Pointer;
import static jnr.ffi.Memory.allocateDirect;
import static jnr.ffi.NativeType.ADDRESS;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.Txn.State.DONE;
import static org.lmdbjava.Txn.State.READY;
import static org.lmdbjava.Txn.State.RELEASED;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* LMDB transaction.
*
* @param <T> buffer type
*/
public final class Txn<T> implements AutoCloseable {
private final KeyVal<T> keyVal;
private final Txn<T> parent;
private final BufferProxy<T> proxy;
private final Pointer ptr;
private final boolean readOnly;
private State state;
Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
final TxnFlags... flags) {
this.proxy = proxy;
this.keyVal = proxy.keyVal();
final int flagsMask = mask(flags);
this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
if (env.isReadOnly() && !this.readOnly) {
throw new EnvIsReadOnly();
}
this.parent = parent;
if (parent != null && parent.isReadOnly() != this.readOnly) {
throw new IncompatibleParent();
}
final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
final Pointer txnParentPtr = parent == null ? null : parent.ptr;
|
checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
|
@Test(expected = BufferMustBeDirectException.class)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
|
try (Env<ByteBuffer> env = create()
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
|
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link ByteBufferProxy}.
*/
public final class ByteBufferProxyTest {
static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
|
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
@Test(expected = BufferMustBeDirectException.class)
public void buffersMustBeDirect() throws IOException {
final File path = tmp.newFolder();
try (Env<ByteBuffer> env = create()
.setMaxReaders(1)
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
|
invokePrivateConstructor(ByteBufferProxy.class);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
.open(path)) {
final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
final ByteBuffer key = allocate(100);
key.putInt(1).flip();
final ByteBuffer val = allocate(100);
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
|
findField(Exception.class, "notARealField");
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
findField(Exception.class, "notARealField");
}
@Test
public void fieldSuperclassScan() {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
val.putInt(1).flip();
db.put(key, val); // error
}
}
@Test
public void byteOrderResets() {
final int retries = 100;
for (int i = 0; i < retries; i++) {
final ByteBuffer bb = PROXY_OPTIMAL.allocate();
bb.order(LITTLE_ENDIAN);
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
findField(Exception.class, "notARealField");
}
@Test
public void fieldSuperclassScan() {
|
final Field f = findField(ReadersFullException.class, "rc");
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
findField(Exception.class, "notARealField");
}
@Test
public void fieldSuperclassScan() {
final Field f = findField(ReadersFullException.class, "rc");
assertThat(f, is(notNullValue()));
}
@Test
public void inOutBuffersProxyOptimal() {
checkInOut(PROXY_OPTIMAL);
}
@Test
public void inOutBuffersProxySafe() {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
PROXY_OPTIMAL.deallocate(bb);
}
for (int i = 0; i < retries; i++) {
assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
}
}
@Test
public void coverPrivateConstructor() {
invokePrivateConstructor(ByteBufferProxy.class);
}
@Test(expected = LmdbException.class)
public void fieldNeverFound() {
findField(Exception.class, "notARealField");
}
@Test
public void fieldSuperclassScan() {
final Field f = findField(ReadersFullException.class, "rc");
assertThat(f, is(notNullValue()));
}
@Test
public void inOutBuffersProxyOptimal() {
checkInOut(PROXY_OPTIMAL);
}
@Test
public void inOutBuffersProxySafe() {
|
checkInOut(PROXY_SAFE);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
public void fieldSuperclassScan() {
final Field f = findField(ReadersFullException.class, "rc");
assertThat(f, is(notNullValue()));
}
@Test
public void inOutBuffersProxyOptimal() {
checkInOut(PROXY_OPTIMAL);
}
@Test
public void inOutBuffersProxySafe() {
checkInOut(PROXY_SAFE);
}
@Test
public void optimalAlwaysAvailable() {
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
}
@Test
public void safeCanBeForced() {
final BufferProxy<ByteBuffer> v = PROXY_SAFE;
assertThat(v, is(notNullValue()));
assertThat(v.getClass().getSimpleName(), startsWith("Reflect"));
}
@Test
public void unsafeIsDefault() {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
public void fieldSuperclassScan() {
final Field f = findField(ReadersFullException.class, "rc");
assertThat(f, is(notNullValue()));
}
@Test
public void inOutBuffersProxyOptimal() {
checkInOut(PROXY_OPTIMAL);
}
@Test
public void inOutBuffersProxySafe() {
checkInOut(PROXY_SAFE);
}
@Test
public void optimalAlwaysAvailable() {
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
}
@Test
public void safeCanBeForced() {
final BufferProxy<ByteBuffer> v = PROXY_SAFE;
assertThat(v, is(notNullValue()));
assertThat(v.getClass().getSimpleName(), startsWith("Reflect"));
}
@Test
public void unsafeIsDefault() {
|
assertThat(ALLOW_UNSAFE, is(true));
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ByteBufferProxyTest.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
|
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
|
public void optimalAlwaysAvailable() {
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
}
@Test
public void safeCanBeForced() {
final BufferProxy<ByteBuffer> v = PROXY_SAFE;
assertThat(v, is(notNullValue()));
assertThat(v.getClass().getSimpleName(), startsWith("Reflect"));
}
@Test
public void unsafeIsDefault() {
assertThat(ALLOW_UNSAFE, is(true));
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
assertThat(v, is(not(PROXY_SAFE)));
assertThat(v.getClass().getSimpleName(), startsWith("Unsafe"));
}
private void checkInOut(final BufferProxy<ByteBuffer> v) {
// allocate a buffer larger than max key size
final ByteBuffer b = allocateDirect(1_000);
b.putInt(1);
b.putInt(2);
b.putInt(3);
b.flip();
b.position(BYTES); // skip 1
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// static Field findField(final Class<?> c, final String name) {
// Class<?> clazz = c;
// do {
// try {
// final Field field = clazz.getDeclaredField(name);
// field.setAccessible(true);
// return field;
// } catch (final NoSuchFieldException e) {
// clazz = clazz.getSuperclass();
// }
// } while (clazz != null);
// throw new LmdbException(name + " not found");
// }
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static void invokePrivateConstructor(final Class<?> clazz) {
// try {
// final Constructor<?> c = clazz.getDeclaredConstructor();
// c.setAccessible(true);
// c.newInstance();
// } catch (final NoSuchMethodException | InstantiationException
// | IllegalAccessException | IllegalArgumentException
// | InvocationTargetException e) {
// throw new LmdbException("Private construction failed", e);
// }
// }
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final class BufferMustBeDirectException extends LmdbException {
//
// private static final long serialVersionUID = 1L;
//
// /**
// * Creates a new instance.
// */
// public BufferMustBeDirectException() {
// super("The buffer must be a direct buffer (not heap allocated");
// }
// }
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final class ReadersFullException extends LmdbNativeException {
//
// static final int MDB_READERS_FULL = -30_790;
// private static final long serialVersionUID = 1L;
//
// ReadersFullException() {
// super(MDB_READERS_FULL, "Environment maxreaders reached");
// }
// }
// Path: src/test/java/org/lmdbjava/ByteBufferProxyTest.java
import static java.lang.Integer.BYTES;
import static java.nio.ByteBuffer.allocate;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.Library.RUNTIME;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.invokePrivateConstructor;
import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
import org.lmdbjava.Env.ReadersFullException;
public void optimalAlwaysAvailable() {
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
}
@Test
public void safeCanBeForced() {
final BufferProxy<ByteBuffer> v = PROXY_SAFE;
assertThat(v, is(notNullValue()));
assertThat(v.getClass().getSimpleName(), startsWith("Reflect"));
}
@Test
public void unsafeIsDefault() {
assertThat(ALLOW_UNSAFE, is(true));
final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
assertThat(v, is(notNullValue()));
assertThat(v, is(not(PROXY_SAFE)));
assertThat(v.getClass().getSimpleName(), startsWith("Unsafe"));
}
private void checkInOut(final BufferProxy<ByteBuffer> v) {
// allocate a buffer larger than max key size
final ByteBuffer b = allocateDirect(1_000);
b.putInt(1);
b.putInt(2);
b.putInt(3);
b.flip();
b.position(BYTES); // skip 1
|
final Pointer p = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/KeyVal.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
|
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.BufferProxy.STRUCT_FIELD_OFFSET_SIZE;
import static org.lmdbjava.Library.RUNTIME;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Represents off-heap memory holding a key and value pair.
*
* @param <T> buffer type
*/
final class KeyVal<T> implements AutoCloseable {
private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
private boolean closed;
private T k;
private final BufferProxy<T> proxy;
private final Pointer ptrArray;
private final Pointer ptrKey;
private final long ptrKeyAddr;
private final Pointer ptrVal;
private final long ptrValAddr;
private T v;
KeyVal(final BufferProxy<T> proxy) {
requireNonNull(proxy);
this.proxy = proxy;
this.k = proxy.allocate();
this.v = proxy.allocate();
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
// Path: src/main/java/org/lmdbjava/KeyVal.java
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.BufferProxy.STRUCT_FIELD_OFFSET_SIZE;
import static org.lmdbjava.Library.RUNTIME;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Represents off-heap memory holding a key and value pair.
*
* @param <T> buffer type
*/
final class KeyVal<T> implements AutoCloseable {
private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
private boolean closed;
private T k;
private final BufferProxy<T> proxy;
private final Pointer ptrArray;
private final Pointer ptrKey;
private final long ptrKeyAddr;
private final Pointer ptrVal;
private final long ptrValAddr;
private T v;
KeyVal(final BufferProxy<T> proxy) {
requireNonNull(proxy);
this.proxy = proxy;
this.k = proxy.allocate();
this.v = proxy.allocate();
|
ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/KeyVal.java
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
|
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.BufferProxy.STRUCT_FIELD_OFFSET_SIZE;
import static org.lmdbjava.Library.RUNTIME;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
|
return v;
}
void valIn(final T val) {
proxy.in(val, ptrVal, ptrValAddr);
}
void valIn(final int size) {
proxy.in(v, size, ptrVal, ptrValAddr);
}
/**
* Prepares an array suitable for presentation as the data argument to a
* <code>MDB_MULTIPLE</code> put.
*
* <p>
* The returned array is equivalent of two <code>MDB_val</code>s as follows:
*
* <ul>
* <li>ptrVal1.data = pointer to the data address of passed buffer</li>
* <li>ptrVal1.size = size of each individual data element</li>
* <li>ptrVal2.data = unused</li>
* <li>ptrVal2.size = number of data elements (as passed to this method)</li>
* </ul>
*
* @param val a user-provided buffer with data elements (required)
* @param elements number of data elements the user has provided
* @return a properly-prepared pointer to an array for the operation
*/
Pointer valInMulti(final T val, final int elements) {
|
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
//
// Path: src/main/java/org/lmdbjava/BufferProxy.java
// protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final jnr.ffi.Runtime RUNTIME;
// Path: src/main/java/org/lmdbjava/KeyVal.java
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
import static org.lmdbjava.BufferProxy.STRUCT_FIELD_OFFSET_SIZE;
import static org.lmdbjava.Library.RUNTIME;
import jnr.ffi.Pointer;
import jnr.ffi.provider.MemoryManager;
return v;
}
void valIn(final T val) {
proxy.in(val, ptrVal, ptrValAddr);
}
void valIn(final int size) {
proxy.in(v, size, ptrVal, ptrValAddr);
}
/**
* Prepares an array suitable for presentation as the data argument to a
* <code>MDB_MULTIPLE</code> put.
*
* <p>
* The returned array is equivalent of two <code>MDB_val</code>s as follows:
*
* <ul>
* <li>ptrVal1.data = pointer to the data address of passed buffer</li>
* <li>ptrVal1.size = size of each individual data element</li>
* <li>ptrVal2.data = unused</li>
* <li>ptrVal2.size = number of data elements (as passed to this method)</li>
* </ul>
*
* @param val a user-provided buffer with data elements (required)
* @param elements number of data elements the user has provided
* @return a properly-prepared pointer to an array for the operation
*/
Pointer valInMulti(final T val, final int elements) {
|
final long ptrVal2SizeOff = MDB_VAL_STRUCT_SIZE + STRUCT_FIELD_OFFSET_SIZE;
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MaskedFlagTest.java
|
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.arrayWithSize;
import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import org.junit.Test;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link MaskedFlag}.
*/
public final class MaskedFlagTest {
@Test
public void isSetOperates() {
|
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
// Path: src/test/java/org/lmdbjava/MaskedFlagTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.arrayWithSize;
import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import org.junit.Test;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link MaskedFlag}.
*/
public final class MaskedFlagTest {
@Test
public void isSetOperates() {
|
assertThat(isSet(0, MDB_NOSYNC), is(false));
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/MaskedFlagTest.java
|
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
|
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.arrayWithSize;
import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import org.junit.Test;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link MaskedFlag}.
*/
public final class MaskedFlagTest {
@Test
public void isSetOperates() {
assertThat(isSet(0, MDB_NOSYNC), is(false));
assertThat(isSet(0, MDB_FIXEDMAP), is(false));
assertThat(isSet(0, MDB_RDONLY_ENV), is(false));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_NOSYNC), is(false));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_FIXEDMAP), is(true));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_RDONLY_ENV), is(false));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_NOSYNC), is(true));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_FIXEDMAP), is(false));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_RDONLY_ENV), is(false));
|
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
// Path: src/test/java/org/lmdbjava/MaskedFlagTest.java
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.arrayWithSize;
import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import org.junit.Test;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link MaskedFlag}.
*/
public final class MaskedFlagTest {
@Test
public void isSetOperates() {
assertThat(isSet(0, MDB_NOSYNC), is(false));
assertThat(isSet(0, MDB_FIXEDMAP), is(false));
assertThat(isSet(0, MDB_RDONLY_ENV), is(false));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_NOSYNC), is(false));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_FIXEDMAP), is(true));
assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_RDONLY_ENV), is(false));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_NOSYNC), is(true));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_FIXEDMAP), is(false));
assertThat(isSet(MDB_NOSYNC.getMask(), MDB_RDONLY_ENV), is(false));
|
final int syncFixed = mask(MDB_NOSYNC, MDB_FIXEDMAP);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/ByteBufferProxy.java
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
|
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import jnr.ffi.Pointer;
import static java.lang.Long.reverseBytes;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
|
}
}
for (int i = minWords * Long.BYTES; i < minLength; i++) {
final int lw = Byte.toUnsignedInt(o1.get(i));
final int rw = Byte.toUnsignedInt(o2.get(i));
final int result = Integer.compareUnsigned(lw, rw);
if (result != 0) {
return result;
}
}
return o1.remaining() - o2.remaining();
}
static Field findField(final Class<?> c, final String name) {
Class<?> clazz = c;
do {
try {
final Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
return field;
} catch (final NoSuchFieldException e) {
clazz = clazz.getSuperclass();
}
} while (clazz != null);
throw new LmdbException(name + " not found");
}
protected final long address(final ByteBuffer buffer) {
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import jnr.ffi.Pointer;
import static java.lang.Long.reverseBytes;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
}
}
for (int i = minWords * Long.BYTES; i < minLength; i++) {
final int lw = Byte.toUnsignedInt(o1.get(i));
final int rw = Byte.toUnsignedInt(o2.get(i));
final int result = Integer.compareUnsigned(lw, rw);
if (result != 0) {
return result;
}
}
return o1.remaining() - o2.remaining();
}
static Field findField(final Class<?> c, final String name) {
Class<?> clazz = c;
do {
try {
final Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
return field;
} catch (final NoSuchFieldException e) {
clazz = clazz.getSuperclass();
}
} while (clazz != null);
throw new LmdbException(name + " not found");
}
protected final long address(final ByteBuffer buffer) {
|
if (SHOULD_CHECK && !buffer.isDirect()) {
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/ByteBufferProxy.java
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
|
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import jnr.ffi.Pointer;
import static java.lang.Long.reverseBytes;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
|
@Override
protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
final long ptrAddr) {
final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
final long size = ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
try {
ADDRESS_FIELD.set(buffer, addr);
CAPACITY_FIELD.set(buffer, (int) size);
} catch (final IllegalArgumentException | IllegalAccessException e) {
throw new LmdbException("Cannot modify buffer", e);
}
buffer.clear();
return buffer;
}
}
/**
* A proxy that uses Java's "unsafe" class to directly manipulate byte buffer
* fields and JNR-FFF allocated memory pointers.
*/
private static final class UnsafeProxy extends AbstractByteBufferProxy {
private static final long ADDRESS_OFFSET;
private static final long CAPACITY_OFFSET;
static {
try {
final Field address = findField(Buffer.class, FIELD_NAME_ADDRESS);
final Field capacity = findField(Buffer.class, FIELD_NAME_CAPACITY);
|
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/UnsafeAccess.java
// static final Unsafe UNSAFE;
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import jnr.ffi.Pointer;
import static java.lang.Long.reverseBytes;
import static java.lang.ThreadLocal.withInitial;
import static java.nio.ByteBuffer.allocateDirect;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.UnsafeAccess.UNSAFE;
import java.lang.reflect.Field;
@Override
protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
final long ptrAddr) {
final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
final long size = ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
try {
ADDRESS_FIELD.set(buffer, addr);
CAPACITY_FIELD.set(buffer, (int) size);
} catch (final IllegalArgumentException | IllegalAccessException e) {
throw new LmdbException("Cannot modify buffer", e);
}
buffer.clear();
return buffer;
}
}
/**
* A proxy that uses Java's "unsafe" class to directly manipulate byte buffer
* fields and JNR-FFF allocated memory pointers.
*/
private static final class UnsafeProxy extends AbstractByteBufferProxy {
private static final long ADDRESS_OFFSET;
private static final long CAPACITY_OFFSET;
static {
try {
final Field address = findField(Buffer.class, FIELD_NAME_ADDRESS);
final Field capacity = findField(Buffer.class, FIELD_NAME_CAPACITY);
|
ADDRESS_OFFSET = UNSAFE.objectFieldOffset(address);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
|
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
|
final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
|
final BufferRunner<byte[]> ba = new ByteArrayRunner(PROXY_BA);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
final BufferRunner<byte[]> ba = new ByteArrayRunner(PROXY_BA);
final BufferRunner<DirectBuffer> db = new DirectBufferRunner();
final BufferRunner<ByteBuf> netty = new NettyBufferRunner();
return new Object[]{bb1, bb2, ba, db, netty};
}
@Test
public void execute() {
runner.execute(tmp);
}
/**
* Abstract implementation of {@link BufferRunner}.
*
* @param <T> buffer type
*/
private abstract static class AbstractBufferRunner<T> implements
BufferRunner<T> {
final BufferProxy<T> proxy;
protected AbstractBufferRunner(final BufferProxy<T> proxy) {
this.proxy = proxy;
}
@Override
public final void execute(final TemporaryFolder tmp) {
try (Env<T> env = env(tmp)) {
assertThat(env.getDbiNames(), empty());
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
/*-
* #%L
* LmdbJava
* %%
* Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.lmdbjava;
/**
* Test {@link Cursor} with different buffer implementations.
*/
@RunWith(Parameterized.class)
public final class CursorParamTest {
/**
* Injected by {@link #data()} with appropriate runner.
*/
@Parameter
public BufferRunner<?> runner;
@Rule
public final TemporaryFolder tmp = new TemporaryFolder();
@Parameters(name = "{index}: buffer adapter: {0}")
public static Object[] data() {
final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
final BufferRunner<byte[]> ba = new ByteArrayRunner(PROXY_BA);
final BufferRunner<DirectBuffer> db = new DirectBufferRunner();
final BufferRunner<ByteBuf> netty = new NettyBufferRunner();
return new Object[]{bb1, bb2, ba, db, netty};
}
@Test
public void execute() {
runner.execute(tmp);
}
/**
* Abstract implementation of {@link BufferRunner}.
*
* @param <T> buffer type
*/
private abstract static class AbstractBufferRunner<T> implements
BufferRunner<T> {
final BufferProxy<T> proxy;
protected AbstractBufferRunner(final BufferProxy<T> proxy) {
this.proxy = proxy;
}
@Override
public final void execute(final TemporaryFolder tmp) {
try (Env<T> env = env(tmp)) {
assertThat(env.getDbiNames(), empty());
|
final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
final int mdb8 = get(c.val());
// assert afterwards to ensure memory address from LMDB
// are valid within same txn and across cursor movement
// MDB_LAST
assertThat(mdb1, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb2, is(8));
}
// MDB_PREV
assertThat(mdb3, is(5));
assertThat(mdb4, is(6));
// MDB_NEXT
assertThat(mdb5, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb6, is(8));
}
// MDB_FIRST
assertThat(mdb7, is(1));
assertThat(mdb8, is(2));
}
}
}
private Env<T> env(final TemporaryFolder tmp) {
try {
final File path = tmp.newFile();
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
final int mdb8 = get(c.val());
// assert afterwards to ensure memory address from LMDB
// are valid within same txn and across cursor movement
// MDB_LAST
assertThat(mdb1, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb2, is(8));
}
// MDB_PREV
assertThat(mdb3, is(5));
assertThat(mdb4, is(6));
// MDB_NEXT
assertThat(mdb5, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb6, is(8));
}
// MDB_FIRST
assertThat(mdb7, is(1));
assertThat(mdb8, is(2));
}
}
}
private Env<T> env(final TemporaryFolder tmp) {
try {
final File path = tmp.newFile();
|
return create(proxy)
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
// MDB_LAST
assertThat(mdb1, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb2, is(8));
}
// MDB_PREV
assertThat(mdb3, is(5));
assertThat(mdb4, is(6));
// MDB_NEXT
assertThat(mdb5, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb6, is(8));
}
// MDB_FIRST
assertThat(mdb7, is(1));
assertThat(mdb8, is(2));
}
}
}
private Env<T> env(final TemporaryFolder tmp) {
try {
final File path = tmp.newFile();
return create(proxy)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
// MDB_LAST
assertThat(mdb1, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb2, is(8));
}
// MDB_PREV
assertThat(mdb3, is(5));
assertThat(mdb4, is(6));
// MDB_NEXT
assertThat(mdb5, is(7));
if (!(this instanceof ByteArrayRunner)) {
assertThat(mdb6, is(8));
}
// MDB_FIRST
assertThat(mdb7, is(1));
assertThat(mdb8, is(2));
}
}
}
private Env<T> env(final TemporaryFolder tmp) {
try {
final File path = tmp.newFile();
return create(proxy)
.setMapSize(KIBIBYTES.toBytes(1_024))
.setMaxReaders(1)
.setMaxDbs(1)
|
.open(path, POSIX_MODE, MDB_NOSUBDIR);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
buff[2] = (byte) (val >>> 8);
buff[3] = (byte) val;
return buff;
}
@Override
public void set(final byte[] buff, final int val) {
buff[0] = (byte) (val >>> 24);
buff[1] = (byte) (val >>> 16);
buff[2] = (byte) (val >>> 8);
buff[3] = (byte) val;
}
}
/**
* {@link BufferRunner} for Java byte buffers.
*/
private static class ByteBufferRunner extends AbstractBufferRunner<ByteBuffer> {
ByteBufferRunner(final BufferProxy<ByteBuffer> proxy) {
super(proxy);
}
@Override
public int get(final ByteBuffer buff) {
return buff.getInt(0);
}
@Override
public ByteBuffer set(final int val) {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
buff[2] = (byte) (val >>> 8);
buff[3] = (byte) val;
return buff;
}
@Override
public void set(final byte[] buff, final int val) {
buff[0] = (byte) (val >>> 24);
buff[1] = (byte) (val >>> 16);
buff[2] = (byte) (val >>> 8);
buff[3] = (byte) val;
}
}
/**
* {@link BufferRunner} for Java byte buffers.
*/
private static class ByteBufferRunner extends AbstractBufferRunner<ByteBuffer> {
ByteBufferRunner(final BufferProxy<ByteBuffer> proxy) {
super(proxy);
}
@Override
public int get(final ByteBuffer buff) {
return buff.getInt(0);
}
@Override
public ByteBuffer set(final int val) {
|
return bb(val);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
*/
private static class ByteBufferRunner extends AbstractBufferRunner<ByteBuffer> {
ByteBufferRunner(final BufferProxy<ByteBuffer> proxy) {
super(proxy);
}
@Override
public int get(final ByteBuffer buff) {
return buff.getInt(0);
}
@Override
public ByteBuffer set(final int val) {
return bb(val);
}
@Override
public void set(final ByteBuffer buff, final int val) {
buff.putInt(val);
}
}
/**
* {@link BufferRunner} for Agrona direct buffer.
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
*/
private static class ByteBufferRunner extends AbstractBufferRunner<ByteBuffer> {
ByteBufferRunner(final BufferProxy<ByteBuffer> proxy) {
super(proxy);
}
@Override
public int get(final ByteBuffer buff) {
return buff.getInt(0);
}
@Override
public ByteBuffer set(final int val) {
return bb(val);
}
@Override
public void set(final ByteBuffer buff, final int val) {
buff.putInt(val);
}
}
/**
* {@link BufferRunner} for Agrona direct buffer.
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
|
super(PROXY_DB);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
}
@Override
public ByteBuffer set(final int val) {
return bb(val);
}
@Override
public void set(final ByteBuffer buff, final int val) {
buff.putInt(val);
}
}
/**
* {@link BufferRunner} for Agrona direct buffer.
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
super(PROXY_DB);
}
@Override
public int get(final DirectBuffer buff) {
return buff.getInt(0);
}
@Override
public DirectBuffer set(final int val) {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
}
@Override
public ByteBuffer set(final int val) {
return bb(val);
}
@Override
public void set(final ByteBuffer buff, final int val) {
buff.putInt(val);
}
}
/**
* {@link BufferRunner} for Agrona direct buffer.
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
super(PROXY_DB);
}
@Override
public int get(final DirectBuffer buff) {
return buff.getInt(0);
}
@Override
public DirectBuffer set(final int val) {
|
return mdb(val);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
super(PROXY_DB);
}
@Override
public int get(final DirectBuffer buff) {
return buff.getInt(0);
}
@Override
public DirectBuffer set(final int val) {
return mdb(val);
}
@Override
public void set(final DirectBuffer buff, final int val) {
((MutableDirectBuffer) buff).putInt(0, val);
}
}
/**
* {@link BufferRunner} for Netty byte buf.
*/
private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
NettyBufferRunner() {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
*/
private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
DirectBufferRunner() {
super(PROXY_DB);
}
@Override
public int get(final DirectBuffer buff) {
return buff.getInt(0);
}
@Override
public DirectBuffer set(final int val) {
return mdb(val);
}
@Override
public void set(final DirectBuffer buff, final int val) {
((MutableDirectBuffer) buff).putInt(0, val);
}
}
/**
* {@link BufferRunner} for Netty byte buf.
*/
private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
NettyBufferRunner() {
|
super(PROXY_NETTY);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/CursorParamTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
|
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
}
@Override
public DirectBuffer set(final int val) {
return mdb(val);
}
@Override
public void set(final DirectBuffer buff, final int val) {
((MutableDirectBuffer) buff).putInt(0, val);
}
}
/**
* {@link BufferRunner} for Netty byte buf.
*/
private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
NettyBufferRunner() {
super(PROXY_NETTY);
}
@Override
public int get(final ByteBuf buff) {
return buff.getInt(0);
}
@Override
public ByteBuf set(final int val) {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufProxy.java
// public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_SAFE;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static Builder<ByteBuffer> create() {
// return new Builder<>(PROXY_OPTIMAL);
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// public static final String DB_1 = "test-db-1";
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// @SuppressWarnings("PMD.AvoidUsingOctalValues")
// public static final int POSIX_MODE = 0664;
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuffer bb(final int value) {
// final ByteBuffer bb = allocateDirect(BYTES);
// bb.putInt(value).flip();
// return bb;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static MutableDirectBuffer mdb(final int value) {
// final MutableDirectBuffer b = new UnsafeBuffer(allocateDirect(BYTES));
// b.putInt(0, value);
// return b;
// }
//
// Path: src/test/java/org/lmdbjava/TestUtils.java
// static ByteBuf nb(final int value) {
// final ByteBuf b = DEFAULT.directBuffer(BYTES);
// b.writeInt(value);
// return b;
// }
// Path: src/test/java/org/lmdbjava/CursorParamTest.java
import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
import static java.lang.Long.BYTES;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsEmptyCollection.empty;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
import static org.lmdbjava.DbiFlags.MDB_CREATE;
import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import static org.lmdbjava.Env.create;
import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
import static org.lmdbjava.GetOp.MDB_SET_KEY;
import static org.lmdbjava.GetOp.MDB_SET_RANGE;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import static org.lmdbjava.TestUtils.DB_1;
import static org.lmdbjava.TestUtils.POSIX_MODE;
import static org.lmdbjava.TestUtils.bb;
import static org.lmdbjava.TestUtils.mdb;
import static org.lmdbjava.TestUtils.nb;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
}
@Override
public DirectBuffer set(final int val) {
return mdb(val);
}
@Override
public void set(final DirectBuffer buff, final int val) {
((MutableDirectBuffer) buff).putInt(0, val);
}
}
/**
* {@link BufferRunner} for Netty byte buf.
*/
private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
NettyBufferRunner() {
super(PROXY_NETTY);
}
@Override
public int get(final ByteBuf buff) {
return buff.getInt(0);
}
@Override
public ByteBuf set(final int val) {
|
return nb(val);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ComparatorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
|
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
assertThat(get(comparator.compare(LH, LX)), is(GREATER_THAN));
assertThat(get(comparator.compare(LX, HL)), is(LESS_THAN));
assertThat(get(comparator.compare(HX, LL)), is(GREATER_THAN));
assertThat(get(comparator.compare(LH, HX)), is(LESS_THAN));
}
@Test
public void equalBuffers() {
assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HX, HX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LH, LH)), is(EQUAL_TO));
assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LX, LX)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
}
/**
* Tests {@link ByteArrayProxy}.
*/
private static class ByteArrayRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
// Path: src/test/java/org/lmdbjava/ComparatorTest.java
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
assertThat(get(comparator.compare(LH, LX)), is(GREATER_THAN));
assertThat(get(comparator.compare(LX, HL)), is(LESS_THAN));
assertThat(get(comparator.compare(HX, LL)), is(GREATER_THAN));
assertThat(get(comparator.compare(LH, HX)), is(LESS_THAN));
}
@Test
public void equalBuffers() {
assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HX, HX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LH, LH)), is(EQUAL_TO));
assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LX, LX)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
}
/**
* Tests {@link ByteArrayProxy}.
*/
private static class ByteArrayRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
|
return PROXY_BA.compare(o1, o2);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ComparatorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
|
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
}
/**
* Tests {@link ByteArrayProxy}.
*/
private static class ByteArrayRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
return PROXY_BA.compare(o1, o2);
}
}
/**
* Tests {@link ByteBufferProxy}.
*/
private static class ByteBufferRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
// Convert arrays to buffers that are larger than the array, with
// limit set at the array length. One buffer bigger than the other.
ByteBuffer o1b = arrayToBuffer(o1, o1.length * 3);
ByteBuffer o2b = arrayToBuffer(o2, o2.length * 2);
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
// Path: src/test/java/org/lmdbjava/ComparatorTest.java
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX)), is(EQUAL_TO));
assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL)), is(EQUAL_TO));
assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
}
/**
* Tests {@link ByteArrayProxy}.
*/
private static class ByteArrayRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
return PROXY_BA.compare(o1, o2);
}
}
/**
* Tests {@link ByteBufferProxy}.
*/
private static class ByteBufferRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
// Convert arrays to buffers that are larger than the array, with
// limit set at the array length. One buffer bigger than the other.
ByteBuffer o1b = arrayToBuffer(o1, o1.length * 3);
ByteBuffer o2b = arrayToBuffer(o2, o2.length * 2);
|
final int result = PROXY_OPTIMAL.compare(o1b, o2b);
|
lmdbjava/lmdbjava
|
src/test/java/org/lmdbjava/ComparatorTest.java
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
|
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
|
o1b = ByteBuffer.wrap(o1);
o2b = ByteBuffer.wrap(o2);
final int result3 = PROXY_OPTIMAL.compare(o1b, o2b);
assertThat(result3, is(result));
return result;
}
private ByteBuffer arrayToBuffer(final byte[] arr, final int bufferCapacity) {
if (bufferCapacity < arr.length) {
throw new IllegalArgumentException("bufferCapacity < arr.length");
}
final byte[] newArr = Arrays.copyOf(arr, bufferCapacity);
final ByteBuffer byteBuffer = ByteBuffer.wrap(newArr);
byteBuffer.limit(arr.length);
byteBuffer.position(0);
return byteBuffer;
}
}
/**
* Tests {@link DirectBufferProxy}.
*/
private static class DirectBufferRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
final DirectBuffer o1b = new UnsafeBuffer(o1);
final DirectBuffer o2b = new UnsafeBuffer(o2);
|
// Path: src/main/java/org/lmdbjava/ByteArrayProxy.java
// public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
//
// Path: src/main/java/org/lmdbjava/ByteBufferProxy.java
// public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
//
// Path: src/main/java/org/lmdbjava/DirectBufferProxy.java
// public static final BufferProxy<DirectBuffer> PROXY_DB
// = new DirectBufferProxy();
// Path: src/test/java/org/lmdbjava/ComparatorTest.java
import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import com.google.common.primitives.SignedBytes;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import org.agrona.DirectBuffer;
import org.agrona.concurrent.UnsafeBuffer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;
o1b = ByteBuffer.wrap(o1);
o2b = ByteBuffer.wrap(o2);
final int result3 = PROXY_OPTIMAL.compare(o1b, o2b);
assertThat(result3, is(result));
return result;
}
private ByteBuffer arrayToBuffer(final byte[] arr, final int bufferCapacity) {
if (bufferCapacity < arr.length) {
throw new IllegalArgumentException("bufferCapacity < arr.length");
}
final byte[] newArr = Arrays.copyOf(arr, bufferCapacity);
final ByteBuffer byteBuffer = ByteBuffer.wrap(newArr);
byteBuffer.limit(arr.length);
byteBuffer.position(0);
return byteBuffer;
}
}
/**
* Tests {@link DirectBufferProxy}.
*/
private static class DirectBufferRunner implements ComparatorRunner {
@Override
public int compare(final byte[] o1, final byte[] o2) {
final DirectBuffer o1b = new UnsafeBuffer(o1);
final DirectBuffer o2b = new UnsafeBuffer(o2);
|
return PROXY_DB.compare(o1b, o2b);
|
lmdbjava/lmdbjava
|
src/main/java/org/lmdbjava/Cursor.java
|
// Path: src/main/java/org/lmdbjava/Dbi.java
// static final int MDB_KEYEXIST = -30_799;
//
// Path: src/main/java/org/lmdbjava/Dbi.java
// static final int MDB_NOTFOUND = -30_798;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
|
import static org.lmdbjava.PutFlags.MDB_RESERVE;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import jnr.ffi.Pointer;
import jnr.ffi.byref.NativeLongByReference;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
|
* Its transaction must still be live if it is a write-transaction.
*/
@Override
public void close() {
if (closed) {
return;
}
if (SHOULD_CHECK && !txn.isReadOnly()) {
txn.checkReady();
}
LIB.mdb_cursor_close(ptrCursor);
kv.close();
closed = true;
}
/**
* Return count of duplicates for current key.
*
* <p>
* This call is only valid on databases that support sorted duplicate data
* items {@link DbiFlags#MDB_DUPSORT}.
*
* @return count of duplicates for current key
*/
public long count() {
if (SHOULD_CHECK) {
checkNotClosed();
txn.checkReady();
}
final NativeLongByReference longByReference = new NativeLongByReference();
|
// Path: src/main/java/org/lmdbjava/Dbi.java
// static final int MDB_KEYEXIST = -30_799;
//
// Path: src/main/java/org/lmdbjava/Dbi.java
// static final int MDB_NOTFOUND = -30_798;
//
// Path: src/main/java/org/lmdbjava/Env.java
// public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
//
// Path: src/main/java/org/lmdbjava/Library.java
// static final Lmdb LIB;
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static boolean isSet(final int flags, final MaskedFlag test) {
// requireNonNull(test);
// return (flags & test.getMask()) == test.getMask();
// }
//
// Path: src/main/java/org/lmdbjava/MaskedFlag.java
// static int mask(final MaskedFlag... flags) {
// if (flags == null || flags.length == 0) {
// return 0;
// }
//
// int result = 0;
// for (final MaskedFlag flag : flags) {
// if (flag == null) {
// continue;
// }
// result |= flag.getMask();
// }
// return result;
// }
//
// Path: src/main/java/org/lmdbjava/ResultCodeMapper.java
// static void checkRc(final int rc) {
// switch (rc) {
// case MDB_SUCCESS:
// return;
// case Dbi.BadDbiException.MDB_BAD_DBI:
// throw new Dbi.BadDbiException();
// case BadReaderLockException.MDB_BAD_RSLOT:
// throw new BadReaderLockException();
// case BadException.MDB_BAD_TXN:
// throw new BadException();
// case Dbi.BadValueSizeException.MDB_BAD_VALSIZE:
// throw new Dbi.BadValueSizeException();
// case LmdbNativeException.PageCorruptedException.MDB_CORRUPTED:
// throw new LmdbNativeException.PageCorruptedException();
// case Cursor.FullException.MDB_CURSOR_FULL:
// throw new Cursor.FullException();
// case Dbi.DbFullException.MDB_DBS_FULL:
// throw new Dbi.DbFullException();
// case Dbi.IncompatibleException.MDB_INCOMPATIBLE:
// throw new Dbi.IncompatibleException();
// case Env.FileInvalidException.MDB_INVALID:
// throw new Env.FileInvalidException();
// case Dbi.KeyExistsException.MDB_KEYEXIST:
// throw new Dbi.KeyExistsException();
// case Env.MapFullException.MDB_MAP_FULL:
// throw new Env.MapFullException();
// case Dbi.MapResizedException.MDB_MAP_RESIZED:
// throw new Dbi.MapResizedException();
// case Dbi.KeyNotFoundException.MDB_NOTFOUND:
// throw new Dbi.KeyNotFoundException();
// case LmdbNativeException.PageFullException.MDB_PAGE_FULL:
// throw new LmdbNativeException.PageFullException();
// case LmdbNativeException.PageNotFoundException.MDB_PAGE_NOTFOUND:
// throw new LmdbNativeException.PageNotFoundException();
// case LmdbNativeException.PanicException.MDB_PANIC:
// throw new LmdbNativeException.PanicException();
// case Env.ReadersFullException.MDB_READERS_FULL:
// throw new Env.ReadersFullException();
// case LmdbNativeException.TlsFullException.MDB_TLS_FULL:
// throw new LmdbNativeException.TlsFullException();
// case TxFullException.MDB_TXN_FULL:
// throw new TxFullException();
// case Env.VersionMismatchException.MDB_VERSION_MISMATCH:
// throw new Env.VersionMismatchException();
// default:
// break;
// }
//
// final Constant constant = CONSTANTS.getConstant(rc);
// if (constant == null) {
// throw new IllegalArgumentException("Unknown result code " + rc);
// }
// final String msg = constant.name() + " " + constant.toString();
// throw new LmdbNativeException.ConstantDerivedException(rc, msg);
// }
// Path: src/main/java/org/lmdbjava/Cursor.java
import static org.lmdbjava.PutFlags.MDB_RESERVE;
import static org.lmdbjava.ResultCodeMapper.checkRc;
import static org.lmdbjava.SeekOp.MDB_FIRST;
import static org.lmdbjava.SeekOp.MDB_LAST;
import static org.lmdbjava.SeekOp.MDB_NEXT;
import static org.lmdbjava.SeekOp.MDB_PREV;
import jnr.ffi.Pointer;
import jnr.ffi.byref.NativeLongByReference;
import static java.util.Objects.requireNonNull;
import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
import static org.lmdbjava.Env.SHOULD_CHECK;
import static org.lmdbjava.Library.LIB;
import static org.lmdbjava.MaskedFlag.isSet;
import static org.lmdbjava.MaskedFlag.mask;
import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
* Its transaction must still be live if it is a write-transaction.
*/
@Override
public void close() {
if (closed) {
return;
}
if (SHOULD_CHECK && !txn.isReadOnly()) {
txn.checkReady();
}
LIB.mdb_cursor_close(ptrCursor);
kv.close();
closed = true;
}
/**
* Return count of duplicates for current key.
*
* <p>
* This call is only valid on databases that support sorted duplicate data
* items {@link DbiFlags#MDB_DUPSORT}.
*
* @return count of duplicates for current key
*/
public long count() {
if (SHOULD_CHECK) {
checkNotClosed();
txn.checkReady();
}
final NativeLongByReference longByReference = new NativeLongByReference();
|
checkRc(LIB.mdb_cursor_count(ptrCursor, longByReference));
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.