// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Set the predicate or the condition for filtering the elements.



Predicate<Integer> moreThan2Pred = (p) -> (p > 1); 



// Use Filter to refine the element set, sort to Sort and Collectors.toSet to get a set out of Stream.



intSet =  intSet.stream().filter(moreThan2Pred).sorted().collect(Collectors.toSet());

    

System.out.println(intSet); // Prints [2, 3, 4]

// Populate a List using Set elements.



// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();

Set<Integer> intSet2 = new HashSet<Integer>(); 



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);

intSet2.add(1);

intSet2.add(2);

intSet2.add(3);

intSet2.add(4); 



// Use the stream and collectors to Summarize all Integer elements 



IntSummaryStatistics summary = intSet.stream().collect(Collectors.summarizingInt(p->((Integer)p)));

 

summary.combine(intSet2.stream().collect(Collectors.summarizingInt(p->((Integer)p))));

 

System.out.println(summary); // Prints IntSummaryStatistics{count=8, sum=20, min=1, average=2.500000, max=4}

String text="vivek boy goy vivek@tech.com viv@ek.com sdjs@adjk";

Pattern regex = Pattern.compile("[@]");

Matcher regexMatcher = regex.matcher(text);

int i =0;

int width = 0;

while (regexMatcher.find()) {

     if((regexMatcher.start()-10 > 0) && (regexMatcher.end()+10 < text.length())){

          width=10;

       String[]    substr=text.substring(regexMatcher.start()-width,regexMatcher.end()+width).split(" ");

           for(int j=0;j<substr.length;j++){

                   if(substr[j].contains("@") && (substr[j].contains(".com") ||    substr[j].contains(".net"))){

                                System.out.println(substr[j]);

                           }                

                     }

               } else {

               width=0;

        }

 }

public enum JavaFramework {

   SPRING("Spring","Web"),

   STRUTS("Struts","Web"),

   JSF("JSF","View"),

   CRUNCH("Apache Crunch","BigData");

   

        

   public String name;

   public String type;



   JavaFramework(String name, String type){

      this.name = name;

      this.type = type;

   }

   

   static public List<JavaFramework> getByType(String type)  {

      List<JavaFramework> frameworks = new ArrayList();

      for(JavaFramework framework: JavaFramework.values()){

         if(framework.type.equalsIgnoreCase(type)){

            frameworks.add(framework);

         }

      }

      

      return frameworks;

   }

}

static {

   timer.schedule(new ScheduledTask(), 60000, 60000);

}



private static class Schedule extends TimerTask {

    @Override public void run() {

      //doSomething();

    }

}

TimeUnit.DAYS.convert(timeinMs, TimeUnit.MILLISECONDS)

Map<String,String> linkedhashmap = new LinkedHashMap();

linkedhashmap.put("United States", "Washington");

linkedhashmap.put("Canada", "Ottawa");

linkedhashmap.put("Canada", "Ottawa");

linkedhashmap.put("South Africa", "Pretoria");

linkedhashmap.put("South Africa", "Cape Town");

linkedhashmap.put("South Africa", "Bloemfontein");



System.out.println(linkedhashmap); // Duplicates not allowed as it's a Map, Insertion Order as its linked Map

    private byte[] deflate(byte[] b) throws IOException {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        DeflaterOutputStream dos = new DeflaterOutputStream(baos);

        dos.write(b);

        dos.close();

        return baos.toByteArray();

    }

  private static CSVReader openCsv(File file) throws IOException {

    final Reader fileReader;

    if (file.getName().endsWith(".gz")) {

      final GZIPInputStream inputStream =

          new GZIPInputStream(new FileInputStream(file));

      fileReader = new InputStreamReader(inputStream);

    } else {

      fileReader = new FileReader(file);

    }

    return new CSVReader(fileReader);

  }

    public Connection createConnection() throws SQLException {

      final Properties info = new Properties();

      for (Map.Entry<String, String> entry : map.entrySet()) {

        info.setProperty(entry.getKey(), entry.getValue());

      }

      Connection connection =

          DriverManager.getConnection("jdbc:calcite:", info);

      for (ConnectionPostProcessor postProcessor : postProcessors) {

        connection = postProcessor.apply(connection);

      }

      return connection;

    }

    private File createBundle(String symbolicName, String version) throws IOException {

        File tmpFile = File.createTempFile("tmpbundle-", "jar");

        tmpFile.deleteOnExit();

        Manifest manifest = new Manifest();

        manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");

        if (symbolicName != null) {

            manifest.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, symbolicName);

        }

        if (version != null) {

            manifest.getMainAttributes().putValue(Constants.BUNDLE_VERSION, version);

        }

        JarOutputStream target = new JarOutputStream(new FileOutputStream(tmpFile), manifest);

        target.close();

        return tmpFile;

    }

regex = Pattern.compile("[http]");

regexMatcher = regex.matcher(htmlParseData.getHtml());

List tr=htmlParseData.getOutgoingUrls();                       

imgUrlCounter=0;

for(i=0;i<tr.size();i++){

          if(tr.get(i).toString().contains(".jpg") || tr.get(i).toString().contains(".jpeg") || tr.get(i).toString().contains(".gif") || tr.get(i).toString().contains(".bmp")){

                   url = new URL(tr.get(i).toString());  

                   Image image = new ImageIcon(url).getImage();

           }

 }

Map<Integer,String> indexedInfo = new HashMap();

indexedInfo.put(1,"Spain");

indexedInfo.put(2,"Denmark");

indexedInfo.put(3,"China");   

Collections.sort(listClassInfo,new Comparator<ClassInfoBean>(){

            public int compare(ClassInfoBean s1,ClassInfoBean s2){

                  if(s1.name.compareTo(s2.name) < 0){

                     return -1;

                  } else {

                     return 1;

                  }

                  

}});

List<Optional<Integer>> intList = new ArrayList<Optional<Integer>>();



// Add Elements



intList.add(Optional.empty());

intList.add(Optional.of(2));

intList.add(Optional.of(3));

intList.add(Optional.of(4));

Calendar calendar = new GregorianCalendar();

float currentTime = calendar.get( Calendar.HOUR_OF_DAY ) + ((float)calendar.get( Calendar.MINUTE )/100);

Date currentDate = Calendar.getInstance().getTime();

Date getDateAfterDays(int numberOfDays){

   Calendar futureDate = Calendar.getInstance();    

   futureDate.setTime(new Date()); // Set Current Date

   futureDate.add(Calendar.DATE, numberOfDays); // Add n days to current Date



   return new Date(futureDate.getTimeInMillis());

}

Date getDateTimeAfterNHours(int numberOfHours){

   Calendar futureTime = Calendar.getInstance();    

   futureTime.setTime(new Date()); // Set Current Date

   futureTime.add(Calendar.HOUR, numberOfDays); // Add n hours to current Date and Time



   return new Date(futureTime.getTimeInMillis());

}

Date date1 = new Date();

       

// Call Service or Method

       

Date date2 = new Date();       

       System.out.println(TimeUnit.SECONDS.convert(date2.getTime()-date1.getTime(), TimeUnit.MILLISECONDS));// Time Taken in Seconds

       System.out.println(TimeUnit.MINUTES.convert(date2.getTime()-date1.getTime(), TimeUnit.MILLISECONDS));// Time Taken in Minutes

       System.out.println(TimeUnit.HOURS.convert(date2.getTime()-date1.getTime(), TimeUnit.MILLISECONDS));// Time Taken in Hours

@Override

    public boolean removeIf(Predicate<? super E> filter) {

        Objects.requireNonNull(filter);

 

        int removeCount = 0;

        final BitSet removeSet = new BitSet(size);

        final int expectedModCount = modCount;

        final int size = this.size;

        for (int i=0; modCount == expectedModCount && i < size; i++) {

            @SuppressWarnings("unchecked")

            final E element = (E) elementData[i];

            if (filter.test(element)) {

                removeSet.set(i);

                removeCount++;

            }

        }

        if (modCount != expectedModCount) {

            throw new ConcurrentModificationException();

        }



        // shift surviving elements left over the spaces left by removed elements

        final boolean anyToRemove = removeCount > 0;

        if (anyToRemove) {

            final int newSize = size - removeCount;

            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {

                i = removeSet.nextClearBit(i);

                elementData[j] = elementData[i];

            }

            for (int k=newSize; k < size; k++) {

                elementData[k] = null;  // Let gc do its work

            }

            this.size = newSize;

            if (modCount != expectedModCount) {

                throw new ConcurrentModificationException();

            }

            modCount++;

        }



        return anyToRemove;

    }

DateMidnight currentDate = new DateMidnight();

DateMidnight dateafterAMonth = currentDate.plusMonths(1);

Date javaSedateAfterAMonth = dateafterAMonth.toDate();

Map<String,String> treemap = new TreeMap();

treemap.put("United States", "Washington");

treemap.put("Canada", "Ottawa");

treemap.put("Canada", "Ottawa");

treemap.put("South Africa", "Pretoria");

treemap.put("South Africa", "Cape Town");

treemap.put("South Africa", "Bloemfontein");



System.out.println(treemap); // Duplicate Not allowed as it's a Map, Ordered by Keys as it's a TreeMap

TimeZone zone = (TimeZone.getDefault().getRawOffset() == EET.getRawOffset() ? EST : EET);

Date expectedZone = createCalendar(zone, 20051231, 0).getTime();

Stack<INodeDirectory> directories = new Stack<INodeDirectory>();

for(directories.push((INodeDirectory)inode); !directories.isEmpty(); ) {

   INodeDirectory d = directories.pop();

}

  public static void main(String[] argv) throws Exception {

    StringUtils.startupShutdownMessage(SecondaryNameNode.class, argv, LOG);

    Configuration tconf = new Configuration();

    if (argv.length >= 1) {

      SecondaryNameNode secondary = new SecondaryNameNode(tconf);

      int ret = secondary.processArgs(argv);

      System.exit(ret);

    }



    Daemon checkpointThread = new Daemon(new SecondaryNameNode(tconf)); 

    checkpointThread.start();

  }

  private static BlockMetadataHeader readHeader(short version, DataInputStream in) 

                                   throws IOException {

    DataChecksum checksum = DataChecksum.newDataChecksum(in);

    return new BlockMetadataHeader(version, checksum);

  }

    public void runScript(List<String> args, File dir) throws IOException {

      ShellCommandExecutor shexec = 

              new ShellCommandExecutor(args.toArray(new String[0]), dir);

      shexec.execute();

      int exitCode = shexec.getExitCode();

      if (exitCode != 0) {

        throw new IOException("Task debug script exit with nonzero status of " 

                              + exitCode + ".");

      }

    }

  public RawKeyValueIterator sort() {

    MergeSort m = new MergeSort(this);

    int count = super.count;

    if (count == 0) return null;

    int [] pointers = super.pointers;

    int [] pointersCopy = new int[count];

    System.arraycopy(pointers, 0, pointersCopy, 0, count);

    m.mergeSort(pointers, pointersCopy, 0, count);

    return new MRSortResultIterator(super.keyValBuffer, pointersCopy, 

                                    super.startOffsets, super.keyLengths, super.valueLengths);

  }

  public static List<String> getNamedOutputsList(JobConf conf) {

    List<String> names = new ArrayList<String>();

    StringTokenizer st = new StringTokenizer(conf.get(NAMED_OUTPUTS, ""), " ");

    while (st.hasMoreTokens()) {

      names.add(st.nextToken());

    }

    return names;

  }

    public static double year()

    {

      Calendar cal = Calendar.getInstance();

      return cal.get(Calendar.YEAR);

    }

    private void readObject(ObjectInputStream s)

        throws IOException, ClassNotFoundException {

        listenerList = NULL_ARRAY;

        s.defaultReadObject();

        Object listenerTypeOrNull;



        while (null != (listenerTypeOrNull = s.readObject())) {

            ClassLoader cl = Thread.currentThread().getContextClassLoader();

            EventListener l = (EventListener)s.readObject();

            String name = (String) listenerTypeOrNull;

            ReflectUtil.checkPackageAccess(name);

            add((Class<EventListener>)Class.forName(name, true, cl), l);

        }

    }

  public Schema create(SchemaPlus parentSchema, String name,

      Map<String, Object> operand) {

    Map map = (Map) operand;

    String host = (String) map.get("host");

    String database = (String) map.get("database");

    return new MongoSchema(host, database);

  }

  public Enumerable<Object[]> scan(DataContext root) {

    final Random random = seed >= 0 ? new Random(seed) : new Random();

    final Maze maze = new Maze(width, height);

    final PrintWriter pw = new PrintWriter(System.out);

    maze.layout(random, pw);

    if (Maze.DEBUG) {

      maze.print(pw, true);

    }

    return new AbstractEnumerable<Object[]>() {

      public Enumerator<Object[]> enumerator() {

        final Set<Integer> solutionSet;

        if (solution) {

          solutionSet = maze.solve(0, 0);

        } else {

          solutionSet = null;

        }

        return Linq4j.transform(maze.enumerator(solutionSet),

            new Function1<String, Object[]>() {

              public Object[] apply(String s) {

                return new Object[] {s};

              }

            });

      }

    };

  }

  private static final FastDateFormat TIME_FORMAT_TIMESTAMP;



  static {

    TimeZone gmt = TimeZone.getTimeZone("GMT");

    TIME_FORMAT_DATE = FastDateFormat.getInstance("yyyy-MM-dd", gmt);

    TIME_FORMAT_TIME = FastDateFormat.getInstance("HH:mm:ss", gmt);

    TIME_FORMAT_TIMESTAMP =

        FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss", gmt);

  }

  private SparkHandlerImpl() {

    classServer = new HttpServer(CLASS_DIR);



    classServer.start();

    System.setProperty("spark.repl.class.uri", classServer.uri());



    final Calendar calendar = Calendar.getInstance();

    classId = new AtomicInteger(

        calendar.get(Calendar.HOUR_OF_DAY) * 10000

        + calendar.get(Calendar.MINUTE) * 100

        + calendar.get(Calendar.SECOND));

  }

    public MapType(SqlParserPos pos) {

      super(pos, Op.MAP_TYPE);

      this.keyType = new ScalarType(pos, "int");

      this.valueType = new ScalarType(pos, "int");

    }

  }



  static class UnParser {

    final StringBuilder buf = new StringBuilder();

    final Spacer spacer = new Spacer(0);

  private static final ThreadLocal<boolean[]> LINUXIFY =

      new ThreadLocal<boolean[]>() {

        @Override protected boolean[] initialValue() {

          return new boolean[] {true};

        }

      };



  Quoting quoting = Quoting.DOUBLE_QUOTE;

  private static final ThreadLocal<boolean[]> LINUXIFY =

      new ThreadLocal<boolean[]>() {

        @Override protected boolean[] initialValue() {

          return new boolean[] {true};

        }

      };



  Quoting quoting = Quoting.DOUBLE_QUOTE;

  Casing unquotedCasing = Casing.TO_UPPER;

    private void defineVariables(String line) {

      Matcher varDefn = matchesVarDefn.matcher(line);

      if (varDefn.lookingAt()) {

        String var = varDefn.group(1);

        String val = varDefn.group(2);

        vars.define(var, val);

      } else {

        String[] words = splitWords.split(line);

        for (String var : words) {

          String value = System.getenv(var);

          vars.define(var, value);

        }

      }

    }

    private List<String> tokenize(String s) {

      List<String> result = new ArrayList<>();

      StringTokenizer tokenizer = new StringTokenizer(s);

      while (tokenizer.hasMoreTokens()) {

        result.add(tokenizer.nextToken());

      }

      return result;

    }

    public final AssertThat withMaterializations(String model,

        Function<JsonBuilder, List<Object>> materializations) {

      final JsonBuilder builder = new JsonBuilder();

      final List<Object> list = materializations.apply(builder);

      final String buf =

          "materializations: " + builder.toJsonString(list);

      final String model2;

      if (model.contains("defaultSchema: 'foodmart'")) {

        model2 = model.replace("]",

            ", { name: 'mat', "

            + buf

            + "}
"

            + "]");

      } else if (model.contains("type: ")) {

        model2 = model.replace("type: ",

            buf + ",
"

            + "type: ");

      } else {

        throw new AssertionError("do not know where to splice");

      }

      return withModel(model2);

    }

      public Void apply(ResultSet resultSet) {

        ++executeCount;

        try {

          final Collection result =

              CalciteAssert.toStringList(resultSet,

                  ordered ? new ArrayList<String>() : new TreeSet<String>());

          if (executeCount == 1) {

            expected = result;

          } else {

            if (!expected.equals(result)) {

              assertThat(newlineList(result), equalTo(newlineList(expected)));

              fail("oops");

            }

          }

          return null;

        } catch (SQLException e) {

          throw new RuntimeException(e);

        }

      }

  private void checkTimestampString(String s, long d) {

    assertThat(unixTimestampToString(d), equalTo(s));

    assertThat(timestampStringToUnixDate(s), equalTo(d));

  }



  @Test public void testIntervalYearMonthToString() {

    TimeUnitRange range = TimeUnitRange.YEAR_TO_MONTH;

    assertEquals("+0-00", intervalYearMonthToString(0, range));

    assertEquals("+1-00", intervalYearMonthToString(12, range));

    assertEquals("+1-01", intervalYearMonthToString(13, range));

    assertEquals("-1-01", intervalYearMonthToString(-13, range));

  }

  private void thereAndBack(byte[] bytes) {

    final ByteString byteString = new ByteString(bytes);

    final byte[] bytes2 = byteString.getBytes();

    assertThat(bytes, equalTo(bytes2));



    final String base64String = byteString.toBase64String();

    final ByteString byteString1 = ByteString.ofBase64(base64String);

    assertThat(byteString, equalTo(byteString1));

  }

    public void testConstructor() throws Exception {

        final ByteArrayBuffer buffer = new ByteArrayBuffer(16);

        Assert.assertEquals(16, buffer.capacity());

        Assert.assertEquals(0, buffer.length());

        Assert.assertNotNull(buffer.buffer());

        Assert.assertEquals(16, buffer.buffer().length);

        try {

            new ByteArrayBuffer(-1);

            Assert.fail("IllegalArgumentException should have been thrown");

        } catch (final IllegalArgumentException ex) {

        }

    }

    public static BitSet INIT_BITSET(final int ... b) {

        final BitSet bitset = new BitSet();

        for (final int aB : b) {

            bitset.set(aB);

        }

        return bitset;

    }

RequestMatcher matcher = new RegexRequestMatcher("(.*/(html|php|htm)/.*)", RequestMethod.GET.name());

registry.addInterceptor(new MyInterceptor(matcher));

    private static List convertArrayToList(Object array)

    {

        int len = Array.getLength(array);

        List list = new ArrayList(len);

        for (int i = 0; i < len; i++)

        {

            list.add(Array.get(array, i));

        }

        return list;

    }

    private long getStoreId(File storeFile) {

        Pattern p = Pattern.compile(m_name + "-(\d+)");

        Matcher m = p.matcher(storeFile.getName());

        if (m.find()) {

            return Long.parseLong(m.group(1));

        }

        throw new RuntimeException("Invalid store file name: " + storeFile.getName());

    }

    public void postEvent(final String topic, Map<String, String> payload) {

        final Map<String, String> eventPayload = new HashMap<>(payload);

        for (final EventListener listener : m_listeners) {

            ScheduledExecutorService executor = getExecutorService();

            if (executor.isShutdown()) {

                logWarning("Cannot post event, executor is shut down!");

                return;

            }

            executor.submit(new Runnable() {

                @Override

                public void run() {

                    try {

                        listener.handle(topic, eventPayload);

                    }

                    catch (Exception e) {

                        logWarning("Exception while posting event", e);

                    }

                }

            });

        }

    }

    public int getDeploymentVersionLimit() {

        Lock lock = m_lock.readLock();

        lock.lock();

        try {

            return m_deploymentVersionLimit;

        }

        finally {

            lock.unlock();

        }

    }

    public void validateRangeIterators() {

        SortedRangeSet srs1 = new SortedRangeSet("1-10");

        Iterator i1 = srs1.rangeIterator();

        assert i1.hasNext() : "We should have one Range instance in our iterator.";

        assert ((Range) i1.next()).toRepresentation().equals("1-10");

        assert !i1.hasNext() : "There should be only one instance in our iterator.";

        SortedRangeSet srs2 = new SortedRangeSet("1-5,8,10-15");

        Iterator i2 = srs2.rangeIterator();

        assert i2.hasNext() && i2.next() instanceof Range

            && i2.hasNext() && i2.next() instanceof Range

            && i2.hasNext() && i2.next() instanceof Range

            && !i2.hasNext() : "There should be exactly three Range instances in our iterator.";

        SortedRangeSet srs3 = new SortedRangeSet("");

        assert !srs3.iterator().hasNext() : "Iterator should be empty.";

    }

    public Set getExtendList() {

        Set set = new HashSet();

        for (Iterator i = requirements.iterator(); i.hasNext();) {

            RequirementImpl impl = (RequirementImpl) i.next();

            if (impl.isExtend())

                set.add(impl);

        }

        return set;

    }

    private File createRandomFileWithContent() throws IOException {

        OutputStream fileOut = null;

        File file = null;

        try {

            file = FileUtils.createTempFile(null);

            fileOut = new FileOutputStream(file);

            byte[] byteArray = new byte[12345];

            Random randomContentCreator = new Random();

            randomContentCreator.nextBytes(byteArray);

            fileOut.write(byteArray);



            return file;

        }

        finally {

            try {

                if (fileOut != null) {

                    fileOut.close();

                }

            }

            catch (IOException e) {

                throw e;

            }

        }

    }

	public LowestID(String representation) {

        try {

            StringTokenizer st = new StringTokenizer(representation, ",");

            m_targetID = Codec.decode(st.nextToken());

            m_storeID = Long.parseLong(st.nextToken());

            m_lowestID = Long.parseLong(st.nextToken());

        }

        catch (NoSuchElementException e) {

            throw new IllegalArgumentException("Could not create lowest ID object from: " + representation);

        }

	}

public class WorkspaceManagerImplTest {

    @SuppressWarnings("serial")

	@Test(groups = { UNIT })

    public void testPropertyGetter() {

        WorkspaceManagerImpl s = new WorkspaceManagerImpl();

        Assert.assertEquals(s.getProperty(new Properties() {{ put("key", "value"); }},  "key", "notused"), "value");

        Assert.assertEquals(s.getProperty(new Properties() {{ put("unusedkey", "value"); }},  "key", "default"), "default");

        Assert.assertEquals(s.getProperty(null,  "key", "default"), "default");

    }

}

    public void testTooLongTask() throws Exception {

        final CountDownLatch latch = new CountDownLatch(5);

        

        Executer executer = new Executer(new Runnable() {

            public void run() {

                try {

                    Thread.sleep(20);

                    latch.countDown();

                }

                catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        });

        executer.start(10);

        assert latch.await(1, TimeUnit.SECONDS);

    }

    private static Calendar getToday() {

        Calendar cal = Calendar.getInstance();

        cal.set(Calendar.HOUR_OF_DAY, 12);

        cal.set(Calendar.MINUTE, 0);

        cal.set(Calendar.SECOND, 0);

        cal.set(Calendar.MILLISECOND, 0);

        return cal;

    }

	protected void configureProvisionedServices() throws Exception {

        m_echoServlet = new EchoServlet();



        Dictionary<String, String> dictionary = new Hashtable<>();

        dictionary.put(HttpConstants.ENDPOINT, "/echoServlet");

        m_echoServletService = m_dependencyManager.createComponent()

            .setImplementation(m_echoServlet)

            .setInterface(Servlet.class.getName(), dictionary);



        m_mockHttp = new MockHttpService();

        m_mockHttpService = m_dependencyManager.createComponent()

            .setImplementation(m_mockHttp)

            .setInterface(HttpService.class.getName(), null);

    }

    public void testEmptyRepository() throws Exception {

        Repository mock = new MockDeploymentRepository("", null, null);

        TestUtils.configureObject(m_backend, Repository.class, mock);



        List<String> versions = m_backend.getVersions(TARGET);

        assert versions.size() == 0 : "From an empty repository, we should get 0 versions, but we get "

            + versions.size();

    }

    private void removeRepository(String instanceName) throws IOException, InterruptedException, InvalidSyntaxException {

        Configuration[] configs = listConfigurations("(factory.instance.pid=" + instanceName + ")");

        if ((configs != null) && (configs.length > 0)) {

            final Semaphore sem = new Semaphore(0);

            ServiceTracker<Object, Object> tracker = new ServiceTracker<Object, Object>(m_bundleContext, m_bundleContext.createFilter("(factory.instance.pid=" + instanceName + ")"), null) {

                @Override

                public void removedService(ServiceReference<Object> reference, Object service) {

                    super.removedService(reference, service);

                    sem.release();

                }

            };

            tracker.open();



            try {

                configs[0].delete();



                if (!sem.tryAcquire(1, TimeUnit.SECONDS)) {

                    throw new IOException("Instance did not get removed in time.");

                }

            }

            finally {

                tracker.close();

            }

        }

    }

    public InputStream getDeploymentPackage(String id, String version) throws OverloadedException, IOException {

        List<ArtifactData> data = m_provider.getBundleData(id, version);

        Manifest manifest = new Manifest();

        Attributes main = manifest.getMainAttributes();



        main.putValue("Manifest-Version", "1.0");

        main.putValue("DeploymentPackage-SymbolicName", id);

        main.putValue("DeploymentPackage-Version", version);



        for (ArtifactData bd : data) {

            manifest.getEntries().put(bd.getFilename(), bd.getManifestAttributes(false));

        }



        return DeploymentPackageStream.createStreamForThread(m_connectionFactory, manifest, data.iterator(), false);

    }

    public InputStream getDeploymentPackage(String id, String version) throws OverloadedException, IOException {

        List<ArtifactData> data = m_provider.getBundleData(id, version);

        Manifest manifest = new Manifest();

        Attributes main = manifest.getMainAttributes();



        main.putValue("Manifest-Version", "1.0");

        main.putValue("DeploymentPackage-SymbolicName", id);

        main.putValue("DeploymentPackage-Version", version);



        for (ArtifactData bd : data) {

            manifest.getEntries().put(bd.getFilename(), bd.getManifestAttributes(false));

        }



        return DeploymentPackageStream.createStreamForThread(m_connectionFactory, manifest, data.iterator(), false);

    }

    public void init(BundleContext context, DependencyManager manager) throws Exception {

        manager.add(createComponent()

            .setInterface(Servlet.class.getName(), null)

            .setImplementation(DeploymentServlet.class)

            .add(createConfigurationDependency().setPropagate(true).setPid(DEPLOYMENT_PID))

            .add(createServiceDependency().setService(StreamGenerator.class).setRequired(true))

            .add(createServiceDependency().setService(DeploymentProvider.class).setRequired(true))

            .add(createServiceDependency().setService(DeploymentProcessor.class).setRequired(false).setCallbacks("addProcessor", "removeProcessor"))

            .add(createServiceDependency().setService(LogService.class).setRequired(false))

        );

        manager.add(createComponent()

            .setInterface(Servlet.class.getName(), null)

            .setImplementation(AgentDeploymentServlet.class)

            .add(createConfigurationDependency().setPropagate(true).setPid(AGENT_PID))

            .add(createServiceDependency().setService(ConnectionFactory.class).setRequired(true))

            .add(createServiceDependency().setService(LogService.class).setRequired(false))

        );

        

        Properties props = new Properties();

        props.put("pattern", "/*");

        manager.add(createComponent()

            .setInterface(Filter.class.getName(), null)

            .setImplementation(OverloadedFilter.class)

        );

    }

    public void hundredStreamsConcurrently() throws Exception {

        ExecutorService e = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {

            e.execute(new Runnable() {

                public void run() {

                    for (int i = 0; i < 10; i++) {

                        try {

                            isJarInputStreamReadable();

                        }

                        catch (Exception e) {

                            m_failure = e;

                        }

                    }

                }

            });

        }

        e.shutdown();

        e.awaitTermination(10, TimeUnit.SECONDS);



        assert m_failure == null : "Test failed: " + m_failure.getLocalizedMessage();

    }

    public void shutdown(long delay) {

        Timer timer = new Timer();

        timer.schedule(new TimerTask() {

            @Override

            public void run() {

                try {

                    m_context.getBundle(0).stop();

                }

                catch (BundleException e) {

                    e.printStackTrace();

                }

            }

        }, delay);

    }

    public static WebResource createEntity(Client c, WebResource work, String type, String data) throws IOException {

        WebResource entity = work.path(type);

        try {

            entity.post(data);

            throw new IOException("Could not create " + type + " with data " + data);

        }

        catch (WebResourceException e2) {

            return c.resource(e2.getResponse().getLocation());

        }

    }

    private boolean checkOSVersions(String currentOSVersion, String[] osversions)

        throws BundleException

    {

        for (int i = 0; (osversions != null) && (i < osversions.length); i++)

        {

            try

            {

                VersionRange range = VersionRange.parse(osversions[i]);

                if (range.isInRange(new Version(currentOSVersion)))

                {

                    return true;

                }

            }

            catch (Exception ex)

            {

                throw new BundleException(

                    "Error evaluating osversion: " + osversions[i], ex);

            }

        }

        return false;

    }

    private static final String DEFAULT_PROPERTIES_FILE = "QueueMonitor.properties";



    String propertiesFile = DEFAULT_PROPERTIES_FILE;

    String broker = "tcp://localhost:61616";

    String connectID = "QueueMonitor";

    String username = "QueueMonitor";

    String password = "QueueMonitor";

    String browseQueues  = "Q1,Q2,Q3";

    String textFontName = "Dialog";

    String textFontStyle = "PLAIN";

    String textFontSize = "12";

    String title = "QueueMonitor";



    JTextArea textArea = new JTextArea();

    JScrollPane scrollPane = new JScrollPane(textArea);

    JButton browseButton = new JButton("Browse Queues");



    Vector theQueues = new Vector();

    private JavaClass getClassFrom(final String where, final String clazzname)

            throws ClassNotFoundException

    {

        final SyntheticRepository repos = createRepos(where);

        return repos.loadClass(clazzname);

    }

    public void test() throws Exception {

        final OutputStream os = new ByteArrayOutputStream();

        final JavaClass java_class = BCELifier.getJavaClass("Java8Example");

        assertNotNull(java_class);

        final BCELifier bcelifier = new BCELifier(java_class, os);

        bcelifier.start();

    }

    public void testSearch() {

        final InstructionList il = new InstructionList();

        il.append(new ILOAD(1));

        il.append(new ILOAD(2));

        il.append(new IADD());

        il.append(new ISTORE(3));

        final InstructionFinder finder = new InstructionFinder(il);



        final Iterator<?> it = finder.search("ILOAD IADD", il.getInstructionHandles()[0], null );

        final InstructionHandle[] ihs = (InstructionHandle[])it.next();

        assertEquals(2, ihs.length);

        assertEquals(ihs[0].getInstruction(), new ILOAD(2));

        assertEquals(ihs[1].getInstruction(), new IADD());

    }

    public static ClassPath.ClassFile lookupClassFile( final String class_name ) {

        try {

            final ClassPath path = repository.getClassPath();

            if (path == null) {

                return null;

            }

            return path.getClassFile(class_name);

        } catch (final IOException e) {

            return null;

        }

    }

    public JavaClass[] getAllInterfaces() throws ClassNotFoundException {

        final ClassQueue queue = new ClassQueue();

        final Set<JavaClass> allInterfaces = new TreeSet<>();

        queue.enqueue(this);

        while (!queue.empty()) {

            final JavaClass clazz = queue.dequeue();

            final JavaClass souper = clazz.getSuperClass();

            final JavaClass[] _interfaces = clazz.getInterfaces();

            if (clazz.isInterface()) {

                allInterfaces.add(clazz);

            } else {

                if (souper != null) {

                    queue.enqueue(souper);

                }

            }

            for (final JavaClass _interface : _interfaces) {

                queue.enqueue(_interface);

            }

        }

        return allInterfaces.toArray(new JavaClass[allInterfaces.size()]);

    }

    public void testClearBitCache() throws IOException {

        final BitInputStream bis = new BitInputStream(getStream(), ByteOrder.LITTLE_ENDIAN);

        assertEquals(0x08, bis.readBits(4));

        bis.clearBitCache();

        assertEquals(0, bis.readBits(1));

        bis.close();

    }

    public void writeTo(final ZipArchiveOutputStream target) throws IOException {

        backingStore.closeForWriting();

        final InputStream data = backingStore.getInputStream();

        for (final CompressedEntry compressedEntry : items) {

            final BoundedInputStream rawStream = new BoundedInputStream(data, compressedEntry.compressedSize);

            target.addRawArchiveEntry(compressedEntry.transferToArchiveEntry(), rawStream);

            rawStream.close();

        }

        data.close();

    }

    public void output() throws Exception {

        final ByteArrayOutputStream bos = new ByteArrayOutputStream();

        final CountingOutputStream o = new CountingOutputStream(bos);

        o.write(1);

        assertEquals(1, o.getBytesWritten());

        o.write(new byte[] { 2, 3 });

        assertEquals(3, o.getBytesWritten());

        o.write(new byte[] { 2, 3, 4, 5, }, 2, 1);

        assertEquals(4, o.getBytesWritten());

        o.count(-1);

        assertEquals(4, o.getBytesWritten());

        o.count(-2);

        assertEquals(2, o.getBytesWritten());

        o.close();

        assertArrayEquals(new byte[] { 1, 2, 3, 4 }, bos.toByteArray());

    }

List<Integer> list1 = Arrays.asList(1, 2);

List<Integer> list2 = Arrays.asList(4, 5);



Stream.of(list1, list1)

  .flatMap(list -> list.stream())

  .forEach(System.out::println);

BiPredicate<String, String> predicate = (s1, s2) -> (s1.equals(s2));



System.out.println(predicate.test("BUGGY", "BREAD"));