text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mayalogy.mayu</groupId>
    <artifactId>mayu-data</artifactId>
    <packaging>jar</packaging>
    <version>1.0.0-SNAPSHOT</version>
    <name>mayu-data</name>
    <url>http://maven.apache.org</url>
    <licenses>
        <license>
            <name>The Apache Software License, Version 2.0</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
        </license>
    </licenses>
    <properties>
        <org.slf4j.version>1.6.4</org.slf4j.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <argLine>-Xms1024m -Xmx2048m</argLine>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-dependency-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>process-sources</phase>

                            <goals>
                                <goal>copy-dependencies</goal>
                            </goals>

                            <configuration>
                                <outputDirectory>${targetdirectory}</outputDirectory>
                            </configuration>
                        </execution>
                    </executions>
            </plugin>
        </plugins>
    </build>
</project>


text:
package net.robig.stlab.gui.preferences;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import javax.swing.JComponent;
import javax.swing.JTextField;
import net.robig.stlab.util.config.StringValue;

/**
 * A preference control for text input
 * @author robig
 *
 */
public class TextPreferenceControl extends AbstractPreferenceControl {

	protected JTextField field=null;
	private StringValue configValue=null;

	public TextPreferenceControl(String name, StringValue config) {
		super(name, config);
		configValue=config;
		initialize();
	}

	protected JTextField getField(){
		return new JTextField(10);
	}

	private void initialize() {
		field=getField();
		//field.setPreferredSize(new Dimension(300, 12));
		/* action listener is performed when closing preferences: */
		field.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				onChange();
			}
		});
		field.addFocusListener(new FocusListener() {

			@Override
			public void focusLost(FocusEvent arg0) {
				onChange();
			}

			@Override
			public void focusGained(FocusEvent arg0) {
			}
		});
		configUpdated();
	}

	/**
	 * on Value change, set Textfield value
	 */
	@Override
	public void onChange() {
		configValue.setValue(field.getText());
	}

	/**
	 * get the Component
	 */
	@Override
	public JComponent getComponent() {
		return field;
	}

	@Override
	public void configUpdated() {
		if(!configValue.getValue().equals(field.getText()))
			field.setText(configValue.getValue());
	}

}

redpajama_set_name: RedPajamaGithub


text:
Place the following files in the 'conf/' directory for OpenVPN configuration:

1. conf/vpnconfig.conf - OpenVPN config

To enable SSL communications for Quassel, also place its server cert at conf/quasselCert.pem


text:
"""
  to test when an id gets loaded into the session
vs when it gets loaded into a context

cmd:env keystore=`pwd` ./id_ctxt.py

"""

import os
import ABAC

def pSZ(CTXT,msg):
   psz= CTXT.principal_count()
   csz= CTXT.credential_count()
   print "context [%s] %d principals, %d credentials" % (msg,psz,csz)

ctxtA = ABAC.Context()
ctxtB = ABAC.Context()

ABAC.dump_debug_info("first")
pSZ(ctxtA, "A")
pSZ(ctxtB, "B")

## creating and writing out using libabac ID
id=ABAC.ID("Ella", 0)
print "adding -> %s(good) to session" % id.id_name()
id.id_write_cert("Ella_ID.pem")
id.id_write_privkey("Ella_private.pem")

ABAC.dump_debug_info("second")
pSZ(ctxtA, "A")
pSZ(ctxtB, "B")

## load principal with id/key file pair
## note, with this, we do not have handle on the keyid
## to Ella but it will be in the db
print "loading -> %s to ctxtA" % id.id_name()
ctxtA.load_id_files("Ella_ID.pem","Ella_private.pem")

print "loading -> Bob to ctxtB"
ctxtB.load_id_files("Bob_ID.pem","Bob_private.pem")

ABAC.dump_debug_info("third")
pSZ(ctxtA, "A")
pSZ(ctxtB, "B")


text:
sort_order: 112
tei_id: p.idm239141647328
annotation_count: 0
images:
  small-thumbnail: http://example.com/books/emory:7st9j/pages/readux-rsk:pgbv4/mini-thumbnail/
  json: http://example.com/books/emory:7st9j/pages/readux-rsk:pgbv4/info/
  full: http://example.com/books/emory:7st9j/pages/readux-rsk:pgbv4/fs/
  page: http://example.com/books/emory:7st9j/pages/readux-rsk:pgbv4/single-page/
  thumbnail: http://example.com/books/emory:7st9j/pages/readux-rsk:pgbv4/thumbnail/
title: Page 112
number: 112
permalink: /pages/112/

---

  {% raw %}ro8 THE BUSINESS OF PLEASURE.{% endraw %}

  {% raw %}mostly from twenty-five to thirty-five years of age; though{% endraw %}

  {% raw %}there is one old man among them who is approaching{% endraw %}

  {% raw %}threescore-and-ten, and Avho is reported almost as good as{% endraw %}

  {% raw %}any of his juniors. They earn from three to four guineas{% endraw %}

  {% raw %}a-Aveek each. The room is large, and though innumerable{% endraw %}

  {% raw %}gaslights are burning, the ventilation is very good.{% endraw %}

  {% raw %}I glanced at some of the writing at which the men Avere{% endraw %}

  {% raw %}working ; and as I thought of the fair round text in Avhich my{% endraw %}

  {% raw %}ledgers and day-books Avere always entered up, and then{% endraw %}

  {% raw %}looked at the thin jigging hieroglyphics which, in close lines,{% endraw %}

  {% raw %}and adorned Avith frequent erasures and corrections, lay{% endraw %}

  {% raw %}before the eyes of those poor compositors, I shuddered at{% endraw %}

  {% raw %}the contrast. On inquiring, hoAvever, I found that the{% endraw %}

  {% raw %}compositors made very light of cacography, and that it AA'as{% endraw %}

  {% raw %}seldom indeed that a man had to refer to his neighbour to{% endraw %}

  {% raw %}help him in deciphering a word.{% endraw %}

  {% raw %}Although a printer may be sitting all day, yet in his own{% endraw %}

  {% raw %}way he is a great traveller, or, at least, his hand is. A good{% endraw %}

  {% raw %}printer will set eight thousand ems a-day, or about twenty-{% endraw %}

  {% raw %}four thousand letters. The distance travelled over by his{% endraw %}

  {% raw %}hand Avill average about one foot per letter, going to the{% endraw %}

  {% raw %}boxes in which they are contained, and of course returning,{% endraw %}

  {% raw %}making two feet every letter he sets. This Avould make{% endraw %}

  {% raw %}a distance each day of forty-eight thousand feet, or a little{% endraw %}

  {% raw %}more than nine miles ; and in a year, leaving out Sundays,{% endraw %}

  {% raw %}that member travels about three thousand miles.{% endraw %}

  {% raw %}From the composing-room I, and a certain amount of{% endraw %}

  {% raw %}type duly set and locked up in a " forme," proceeded to the{% endraw %}

  {% raw %}foundry—a workshop covered with scraps of metal-filings,{% endraw %}

  {% raw %}and with a furnace in the middle of it Unlike their felloAA'-{% endraw %}

  {% raw %}Avorkmen of the village of Auburn, as described by Goldsmith,{% endraw %}

  {% raw %}the smiths in the foundry of my journal by no means relaxed{% endraw %}

  {% raw %}their ponderous strengths and leaned to hear, but were{% endraw %}

  {% raw %}obviously far too hard at work to do anything of the kind.{% endraw %}

  {% raw %}So soon as the type-containing formes arrive, they are{% endraw %}


text:
package org.hoteia.qalingo.core.web.mvc.controller.security;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import org.hoteia.qalingo.core.ModelConstants;
import org.hoteia.qalingo.core.domain.enumtype.BoUrls;
import org.hoteia.qalingo.core.web.mvc.controller.AbstractBackofficeQalingoController;
import org.hoteia.qalingo.core.web.mvc.viewbean.SecurityViewBean;
import org.hoteia.qalingo.core.web.servlet.ModelAndViewThemeDevice;

/**
 *
 */
@Controller("forbiddenController")
public class ForbiddenController extends AbstractBackofficeQalingoController {

	@RequestMapping(BoUrls.FORBIDDEN_URL)
	public ModelAndView forbidden(final HttpServletRequest request, final HttpServletResponse response) throws Exception {
		ModelAndViewThemeDevice modelAndView = new ModelAndViewThemeDevice(getCurrentVelocityPath(request), BoUrls.FORBIDDEN.getVelocityPage());

        return modelAndView;
	}

	@ModelAttribute(ModelConstants.SECURITY_VIEW_BEAN)
	protected SecurityViewBean initSecurityViewBean(final HttpServletRequest request, final Model model) throws Exception {
		return backofficeViewBeanFactory.buildViewBeanSecurity(requestUtil.getRequestData(request));
	}

}


text:
package nizomjon.rxconnectionstatusview;

/**
 * Created by Nizomjon on 03/04/2017.
 */

public class NetworkState {
    private int statusId;
    private boolean isOnline;

    public NetworkState(int statusId, boolean isOnline) {
        this.statusId = statusId;
        this.isOnline = isOnline;
    }

    public int getStatusId() {
        return statusId;
    }

    public void setStatusId(int statusId) {
        this.statusId = statusId;
    }

    public boolean isOnline() {
        return isOnline;
    }

    public void setOnline(boolean online) {
        isOnline = online;
    }
}


text:
Inversion of control : router (generic code) call and use custom/reusable code (maps - views or others)

Facade	 A single class that hides the complexity of an entire subsystem.


text:
Defining {{#linkTo "show_components.tabs"}}Tab Component{{/linkTo}} covers the Tabs rendering and help you to interact with the selected tab. But usually some content should be rendered as a response for a tab click right?

This is where _Tab Panes_ come into play, a tab pane is the content area of each rendered tab, when a tab is selected, the corresponding _tab pane_ becomes visible, see below for the possible options.

Tab Panes expects a `contentBinding` property just like the _bs-tabs_ component, the _Tabs Panes_ component also must be aware of the _bs-tabs_ component it is bound to by specifying the _items-id_ property set to the _id_ of the corresponding _bs-tabs_

<div class="bs-example">
    {{bs-tabs id="tabs1" contentBinding="tabsMeta" default="Foo"}}
    {{bs-tabs-panes items-id="tabs1" contentBinding="tabsMeta"}}
</div>

``` html
\{\{bs-tabs id="tabs1" contentBinding="tabsMeta" default="Foo"\}\}
\{\{bs-tabs-panes items-id="tabs1" contentBinding="tabsMeta"\}\}
```

* An `id` property is required for the _bs-tabs_.
* The _bs-tabs-panes_ generates a tab pane per element in the _content_ array.
* The `items-id` property must refer to the `id` of the `bs-tabs` component.
* If you like one tab to be activated by default, set the `default` property of the _bs-tabs_ component to a title of the tab you would like to be activated by default.

Here is the controller _tabsPanesOptions_ property:

``` javascript
SomeController = Ember.Controller.extend({
    tabsMeta: Ember.A([
            Ember.Object.create({ title: 'Foo', template: 'tabs/foo-tabpane', controller: 'ShowcaseComponentsTabsFoo'}),
            Ember.Object.create({ title: 'Bar', template: 'tabs/bar-tabpane'})
    ]);
});

The `template: 'some-template'` defines what template to render in the corresponding _Tab Pane_ when the Tab is selected.

```
Note that for the `Foo` tab, a `controller` property was defined, calling `\{\{controller\}\}` within the tab pane template `tabs/foo-tabpane` will point to the specified `ShowcaseComponentsTabsFoo` controller instead of the default controller
which is the controller of the template the `\{\{bs-tabs-panes\}\}` was called from.

Thats all needed! awesome isn't it?


text:
#!/usr/bin/env node

/**
 * Exposes front end API.
 * Shawn Rapp - 11/25/2014
 */
function ApiSubSystem() {
    var plsub = require('party-line-sub')('API');
    var universal_cache = {};

    /* extract what is needed out of PLSub but don't pass the entire object.
      Ideally every function in API module would be a derivative internal function
      like sendNoResponsePacket. */
    var API = {
        sendNoReponsePacket: sendNoReponsePacket,
        logger: plsub.logger,
        send: plsub.send,
        requestService: plsub.requestService
    };

    plsub.addListeningContext('web.api');
    plsub.addListeningContext('api');

    plsub.on('request', filterAPIRequests);

    function sendNoReponsePacket(request_packet) {
        var noroute_packet = {
            type: 'noResponse',
            context: request_packet.from,
            request_id: request_packet.request_id
        };
        plsub.send(noroute_packet);
    }

    function filterAPIRequests(request_packet) {
        var reg_pat = /^\/api\/(.*)/;
        var request_matches = request_packet.request.match(reg_pat);
        if (request_matches.length > 0) {
            var path = require('path');
            var api_request = path.join('extensions', request_matches[1]);
            sendAPI(api_request, request_packet);
        }
        else {
            sendNoReponsePacket(request_packet);
        }
    }

    function sendAPI(api_request, request_packet) {
        try {
            plsub.logger.info('attempted API call.', api_request);
            var mod = require('./' + api_request)(API, universal_cache);
            mod.run(request_packet);
        }
        catch (e) {
            plsub.logger.error('API ERROR', e);
            sendNoReponsePacket(request_packet);
            return;
        }
    }
}

ApiSubSystem();


text:
/**
 *
 */
package com.kevlindev.pipistrello;

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * @author Kevin Lindsey
 */
public class SerialReader implements Runnable {
	private InputStream in;
	private DataInputStream dis;

	public SerialReader(InputStream in) {
		this.in = in;
		this.dis = new DataInputStream(this.in);
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see java.lang.Runnable#run()
	 */
	@Override
	public void run() {
		boolean run = true;

		try
		{
			while (run) {
				if (this.dis.available() > 0) {
					byte command = this.dis.readByte();

					switch (command) {
					case 'd':
					{
						int byteCount = dis.readInt();
						int[] pixels = new int[byteCount / 4];
						int i = 0;

						try {
							for (i = 0; i < byteCount / 4; i++) {
								if (i != 0 && (i % 640) == 0) System.out.print(".");
								if (i != 0 && (i % (640*40)) == 0) System.out.println();
								//while (this.dis.available() < 4);
								pixels[i] = dis.readInt();
							}
							System.out.println();
						}
						catch (IOException e) {
							// ignore
						}

						System.out.println("Read " + (i*4) + " bytes out of " + byteCount);

						DataOutputStream dos = null;

						try {
							dos = new DataOutputStream(
								new BufferedOutputStream(
									new FileOutputStream(
										new File("C:\\Users\\Kevin Lindsey\\Desktop\\screen.raw")
									)
								)
							);
							for (int pixel : pixels) {
								dos.writeInt(pixel);
							}
						} catch (IOException e) {
							throw new RuntimeException(e);
						} finally {
							try {
								if (dos != null) {
									dos.close();
								}
							} catch (IOException e) {
								// do nothing
							}
						}

						/*
						DataBufferInt buffer = new DataBufferInt(pixels, 640 * 480);
						int bitMask[] = new int[] { 0xff0000, 0xff00, 0xff, 0xff000000 };
						SinglePixelPackedSampleModel sampleModel = new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT, 640, 480, bitMask);
						WritableRaster raster = Raster.createWritableRaster(sampleModel, buffer, null);
						BufferedImage image = new BufferedImage(ColorModel.getRGBdefault(), raster, false, null);
						ImageIO.write(image, "png", new File("C:\\Users\\Kevin Lindsey\\Desktop\\screen.png"));
						*/

						// exit runnable until we make input block properly
						run = false;

						break;
					}

					default:
						System.out.print((char) command);
					}
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}


text:
//
// Copyright (c) Microsoft.  All rights reserved.
//
// 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.
//

using Microsoft.Azure.Management.Compute;
using Microsoft.Azure.Management.Compute.Models;
using Microsoft.Azure.Management.Network;
using Microsoft.Azure.Management.Network.Models;
using Microsoft.Azure.Management.Resources;
using Microsoft.Azure.Management.Resources.Models;
using Microsoft.Azure.Management.Storage;
using Microsoft.Azure.Management.Storage.Models;
using Microsoft.Azure.Test;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using Microsoft.Azure.Test.HttpRecorder;
using Xunit;

namespace Compute.Tests
{
    public class OSProfileTests : VMTestBase
    {
        private static readonly string CustomData = Convert.ToBase64String(Encoding.UTF8.GetBytes("echo 'Hello World'"));

        private const string OOBESystem = PassNames.OOBESystem;
        private const string MicrosoftWindowsShellSetup = ComponentNames.MicrosoftWindowsShellSetup;
        private const string AutoLogon = SettingNames.AutoLogon;

        private const string PacificStandardTime = "Pacific Standard Time";

        private const string DefaultSshPublicKey =
            "MIIDszCCApugAwIBAgIJALBV9YJCF/tAMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV" +
            "BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX" +
            "aWRnaXRzIFB0eSBMdGQwHhcNMTUwMzIyMjI1NDQ5WhcNMTYwMzIxMjI1NDQ5WjBF" +
            "MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50" +
            "ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIB" +
            "CAKCAQEAxDC+OfmB+tQ+P1MLmuuW2hJLdcK8m4DLgAk5l8bQDNBcVezt+bt/ZFMs" +
            "CHBhfTZG9O9yqMn8IRUh7/7jfQm6DmXCgtxj/uFiwT+F3out5uWvMV9SjFYvu9kJ" +
            "NXiDC2u3l4lHV8eHde6SbKiZB9Jji9FYQV4YiWrBa91j9I3hZzbTL0UCiJ+1PPoL" +
            "Rx/T1s9KT5Wn8m/z2EDrHWpetYu45OA7nzyIFOyQup5oWadWNnpk6HkCGutl9t9b" +
            "cLdjXjXPm9wcy1yxIB3Dj/Y8Hnulr80GJlUtUboDm8TExGc4YaPJxdn0u5igo5gZ" +
            "c6qnqH/BMd1nsyICx6AZnKBXBycoSQIBI6OBpzCBpDAdBgNVHQ4EFgQUzWhrCCDs" +
            "ClANCGlKZ64rHp2BDn0wdQYDVR0jBG4wbIAUzWhrCCDsClANCGlKZ64rHp2BDn2h" +
            "SaRHMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQK" +
            "ExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGSCCQCwVfWCQhf7QDAMBgNVHRMEBTAD" +
            "AQH/MA0GCSqGSIb3DQEBBQUAA4IBAQCUaJnX0aBzwBkbJrBS5YvkZnNKLdc4oHgC" +
            "/Nsr/9pwXzFYYXkdqpTw2nygH0C0WuPVVrG3Y3EGx/UIGDtLbwMvZJhQN9mZH3oX" +
            "+c3HGqBnXGuDRrtsfsK1ywAofx9amZfKNk/04/Rt3POdbyD1/AOADw2zMokbIapX" +
            "+nMDUtD/Tew9+0qU9+dcFMrFE1N4utlrFHlrLFbiCA/eSegP6gOeu9mqZv7UHIz2" +
            "oe6IQTw7zJF7xuBIzTYwjOCM197GKW7xc4GU4JZIN+faZ7njl/fxfUNdlqvgZUUn" +
            "kfdrzU3PZPl0w9NuncgEje/PZ+YtZvIsnH7MLSPeIGNQwW6V2kc8";

        [Fact(Skip = "TODO: Wait for KMS Client")]
        public void TestVMWithWindowsOSProfile()
        {
            string autoLogonContentFormat =
                "<UserAccounts><AdministratorPassword><Value>{0}</Value><PlainText>true</PlainText></AdministratorPassword></UserAccounts>";
            string autoLogonContent = null;
            Uri winRMCertificateUrl = new Uri("http://keyVaultName.vault.azure.net/secrets/secretName/secretVersion");

            Action<VirtualMachine> enableWinRMCustomDataAndUnattendContent = inputVM =>
            {
                OSProfile osProfile = inputVM.OSProfile;
                osProfile.CustomData = CustomData;
                // Used for verification
                autoLogonContent = string.Format(autoLogonContentFormat, osProfile.AdminPassword);
                osProfile.WindowsConfiguration = new WindowsConfiguration
                {
                    ProvisionVMAgent = true,
                    EnableAutomaticUpdates = false,
                    TimeZone = PacificStandardTime,
                    AdditionalUnattendContents = new List<AdditionalUnattendContent>
                    {
                        new AdditionalUnattendContent
                        {
                            PassName = OOBESystem,
                            ComponentName = MicrosoftWindowsShellSetup,
                            SettingName = AutoLogon,
                            Content = autoLogonContent
                        }
                    },
                    WinRMConfiguration = new WinRMConfiguration
                    {
                        Listeners = new List<WinRMListener>
                        {
                            new WinRMListener
                            {
                                Protocol = ProtocolTypes.Http,
                                CertificateUrl = null,
                            },
                            // TODO: Add WinRM tests when KMS is ready
                            /*
                            new WinRMListener
                            {
                                Protocol = ProtocolTypes.Https,
                                CertificateUrl = winRMCertificateUrl,
                            }
                            */
                        }
                    },
                };
            };

            Action<VirtualMachine> validateWinRMCustomDataAndUnattendContent = outputVM =>
            {
                OSProfile osProfile = outputVM.OSProfile;
                // CustomData:
                Assert.Equal(osProfile.CustomData, CustomData);

                Assert.Null(osProfile.LinuxConfiguration);
                Assert.NotNull(osProfile.WindowsConfiguration);

                Assert.True(osProfile.WindowsConfiguration.ProvisionVMAgent.Value);
                Assert.False(osProfile.WindowsConfiguration.EnableAutomaticUpdates.Value);

                // TimeZone
                Assert.Equal(PacificStandardTime, osProfile.WindowsConfiguration.TimeZone);

                // WinRM
                Assert.NotNull(osProfile.WindowsConfiguration.WinRMConfiguration);
                var listeners = osProfile.WindowsConfiguration.WinRMConfiguration.Listeners;
                Assert.NotNull(listeners);
                Assert.Equal(2, listeners.Count);

                if (listeners[0].Protocol.Equals(ProtocolTypes.Http, StringComparison.InvariantCultureIgnoreCase))
                {
                    Assert.Null(listeners[0].CertificateUrl);

                    Assert.True(listeners[1].Protocol.Equals(ProtocolTypes.Https, StringComparison.InvariantCultureIgnoreCase));
                    // TODO: verify exact url once secrets are in
                    Assert.NotNull(listeners[1].CertificateUrl);
                }
                else if (listeners[0].Protocol.Equals(ProtocolTypes.Https, StringComparison.InvariantCultureIgnoreCase))
                {
                    // TODO: verify exact url once secrets are in
                    Assert.NotNull(listeners[0].CertificateUrl);

                    Assert.True(listeners[1].Protocol.Equals(ProtocolTypes.Http, StringComparison.InvariantCultureIgnoreCase));
                    Assert.Null(listeners[1].CertificateUrl);
                }
                else
                {
                    // Unexpected value for winRM Listener protocol
                    Assert.True(false);
                }

                // AdditionalUnattendContent
                var additionalContents = osProfile.WindowsConfiguration.AdditionalUnattendContents;
                Assert.NotNull(additionalContents);
                Assert.Equal(1, additionalContents.Count);
                Assert.Equal(OOBESystem, additionalContents[0].PassName);
                Assert.Equal(MicrosoftWindowsShellSetup, additionalContents[0].ComponentName);
                Assert.Equal(AutoLogon, additionalContents[0].SettingName);
                Assert.Equal(autoLogonContent, additionalContents[0].Content);
            };

            using (var context = UndoContext.Current)
            {
                context.Start();
                EnsureClientsInitialized();

                TestVMWithOSProfile(
                    useWindowsProfile: true,
                    vmCustomizer: enableWinRMCustomDataAndUnattendContent,
                    vmValidator: null);
                    //vmValidator: validateWinRMCustomDataAndUnattendContent);
            }
        }

        [Fact]
        public void TestVMWithLinuxOSProfile()
        {
            string sshPath = null;

            Action<VirtualMachine> enableSSHAndCustomData = customizedVM =>
            {
                OSProfile osProfile = customizedVM.OSProfile;
                sshPath = "/home/" + osProfile.AdminUsername + "/.ssh/authorized_keys";
                osProfile.CustomData = CustomData;
                osProfile.LinuxConfiguration = new LinuxConfiguration
                {
                    DisablePasswordAuthentication = false,
                    SshConfiguration = new SshConfiguration
                    {
                        PublicKeys = new List<SshPublicKey>
                        {
                            new SshPublicKey
                            {
                                Path = sshPath,
                                KeyData = DefaultSshPublicKey,
                            }
                        }
                    }
                };
            };

            Action<VirtualMachine> validateWinRMCustomDataAndUnattendContent = outputVM =>
            {
                OSProfile osProfile = outputVM.OSProfile;
                Assert.Equal<string>(CustomData, osProfile.CustomData);

                Assert.Null(osProfile.WindowsConfiguration);

                Assert.NotNull(osProfile.LinuxConfiguration);
                Assert.NotNull(osProfile.LinuxConfiguration.SshConfiguration);
                var publicKeys = osProfile.LinuxConfiguration.SshConfiguration.PublicKeys;
                Assert.NotNull(osProfile.LinuxConfiguration.SshConfiguration.PublicKeys);

                Assert.False(osProfile.LinuxConfiguration.DisablePasswordAuthentication.Value);

                Assert.Equal(1, publicKeys.Count);
                Assert.Equal(sshPath, publicKeys[0].Path);
                Assert.Equal(DefaultSshPublicKey, publicKeys[0].KeyData);
            };

            using (var context = UndoContext.Current)
            {
                context.Start();
                EnsureClientsInitialized();

                TestVMWithOSProfile(
                    useWindowsProfile: false,
                    vmCustomizer: enableSSHAndCustomData,
                    vmValidator: validateWinRMCustomDataAndUnattendContent);
            }
        }

        private void TestVMWithOSProfile(
            bool useWindowsProfile,
            Action<VirtualMachine> vmCustomizer = null,
            Action<VirtualMachine> vmValidator = null)
        {
            string rgName = TestUtilities.GenerateName(TestPrefix);
            string storageAccountName = TestUtilities.GenerateName(TestPrefix);
            string asName = TestUtilities.GenerateName("as");

            string imgRefId = GetPlatformOSImage(useWindowsProfile);

            VirtualMachine inputVM;
            try
            {
                StorageAccount storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);

                VirtualMachine vm = CreateVM(rgName, asName, storageAccountOutput, imgRefId, out inputVM, vmCustomizer);

                // TODO: Remove these 2 lines once tested against prod (re-recording occurs).
                // These 2 lines are needed since the previous operation does a Get, which in the old recording does not
                // return the CreateOptionType required field.
                vm.StorageProfile.DataDisks.ForEach(dd => dd.CreateOption = DiskCreateOptionTypes.Empty);
                vm.StorageProfile.OSDisk.CreateOption = DiskCreateOptionTypes.Empty;

                VirtualMachineGetResponse getVMWithInstanceViewResponse =
                    m_CrpClient.VirtualMachines.GetWithInstanceView(rgName, inputVM.Name);
                Assert.True(getVMWithInstanceViewResponse.StatusCode == HttpStatusCode.OK);
                ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse.VirtualMachine);

                var lroResponse = m_CrpClient.VirtualMachines.CreateOrUpdate(rgName, vm);
                Assert.True(lroResponse.Status == ComputeOperationStatus.Succeeded);
                if (vmValidator != null)
                {
                    vmValidator(vm);
                }

                var deleteOperationResponse = m_CrpClient.VirtualMachines.BeginDeleting(rgName, vm.Name);
                Assert.True(deleteOperationResponse.StatusCode == HttpStatusCode.Accepted);

                // TODO: VM delete operation takes too long, disable it for now
                // lroResponse = m_CrpClient.VirtualMachines.Delete(rgName, vm.Name);
                // Assert.True(lroResponse.Status == ComputeOperationStatus.Succeeded);
            }
            finally
            {
                if (m_ResourcesClient != null)
                {
                    // TODO: RG delete operation takes too long, disable it for now
                    // var deleteResourceGroupResponse = m_ResourcesClient.ResourceGroups.Delete(rgName);
                    // Assert.True(deleteResourceGroupResponse.StatusCode == HttpStatusCode.OK);
                    var deleteResourceGroupResponse = m_ResourcesClient.ResourceGroups.BeginDeleting(rgName);
                    Assert.True(deleteResourceGroupResponse.StatusCode == HttpStatusCode.Accepted);
                }
            }
        }
    }
}


text:
module.exports = () => {
    return (files, metalsmith, done) => {
        removeEmptyFiles(files);
        done();
    };
};

function removeEmptyFiles(files) {
    Object.keys(files).forEach((file) => {
        if (files[file].nav_category) {
            delete files[file];
        }
    });
}


text:
<!doctype html>

    <title>Code coverage report for expressMongo\routes\signoutRoute.js</title>
    <meta charset="utf-8" />
    <link rel="stylesheet" href="../../prettify.css" />
    <link rel="stylesheet" href="../../base.css" />
    <meta name="viewport" content="width=device-width, initial-scale=1">

      all files / expressMongo/routes/ signoutRoute.js

        62.5%
        Statements
        5/8

        100%
        Branches
        0/0

        0%
        Functions
        0/1

        62.5%
        Lines
        5/8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16	1×
1×

1×

1×

1×

var express = require('express');
var router = express.Router();

var checkLogin = require('../middlewares/check').checkLogin;

// GET /signout 登出
router.get('/', checkLogin, function(req, res, next) {
    // 清空 session 中用户信息
    req.session.user = null;
    req.flash('success', '登出成功');
    // 登出成功后跳转到主页
    res.redirect('/articles');
});

module.exports = router;

  Code coverage
  generated by istanbul at Thu Mar 30 2017 15:38:47 GMT+0800 (中国标准时间)


text:
package org.nanoframework.concurrent.scheduler;

import java.io.Serializable;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TimeZone;
import java.util.TreeSet;

/**
 *
 *
 * @author Sharada Jambula, James House
 * @author Contributions from Mads Henderson
 * @author Refactoring from CronTrigger to CronExpression by Aaron Craven
 */
public final class CronExpression implements Serializable, Cloneable {

    private static final long serialVersionUID = 12423409423L;

    protected static final int SECOND = 0;
    protected static final int MINUTE = 1;
    protected static final int HOUR = 2;
    protected static final int DAY_OF_MONTH = 3;
    protected static final int MONTH = 4;
    protected static final int DAY_OF_WEEK = 5;
    protected static final int YEAR = 6;
    protected static final int ALL_SPEC_INT = 99; // '*'
    protected static final int NO_SPEC_INT = 98; // '?'
    protected static final Integer ALL_SPEC = ALL_SPEC_INT;
    protected static final Integer NO_SPEC = NO_SPEC_INT;

    protected final Map<String, Integer> monthMap = new HashMap<String, Integer>(20);
    protected final Map<String, Integer> dayMap = new HashMap<String, Integer>(60);
    {
        monthMap.put("JAN", 0);
        monthMap.put("FEB", 1);
        monthMap.put("MAR", 2);
        monthMap.put("APR", 3);
        monthMap.put("MAY", 4);
        monthMap.put("JUN", 5);
        monthMap.put("JUL", 6);
        monthMap.put("AUG", 7);
        monthMap.put("SEP", 8);
        monthMap.put("OCT", 9);
        monthMap.put("NOV", 10);
        monthMap.put("DEC", 11);

        dayMap.put("SUN", 1);
        dayMap.put("MON", 2);
        dayMap.put("TUE", 3);
        dayMap.put("WED", 4);
        dayMap.put("THU", 5);
        dayMap.put("FRI", 6);
        dayMap.put("SAT", 7);
    }

    private final String cronExpression;
    private TimeZone timeZone = null;
    protected transient TreeSet<Integer> seconds;
    protected transient TreeSet<Integer> minutes;
    protected transient TreeSet<Integer> hours;
    protected transient TreeSet<Integer> daysOfMonth;
    protected transient TreeSet<Integer> months;
    protected transient TreeSet<Integer> daysOfWeek;
    protected transient TreeSet<Integer> years;

    protected transient boolean lastdayOfWeek = false;
    protected transient int nthdayOfWeek = 0;
    protected transient boolean lastdayOfMonth = false;
    protected transient boolean nearestWeekday = false;
    protected transient int lastdayOffset = 0;
    protected transient boolean expressionParsed = false;

    public static final int MAX_YEAR = Calendar.getInstance().get(Calendar.YEAR) + 100;

    /**
     * Constructs a new CronExpression based on the specified
     * parameter.
     *
     * @param cronExpression String representation of the cron expression the
     *                       new object should represent
     * @throws java.text.ParseException
     *         if the string expression cannot be parsed into a valid
     *         CronExpression
     */
    public CronExpression(String cronExpression) throws ParseException {
        if (cronExpression == null) {
            throw new IllegalArgumentException("cronExpression cannot be null");
        }

        this.cronExpression = cronExpression.toUpperCase(Locale.US);

        buildExpression(this.cronExpression);
    }

    /**
     * Constructs a new {@code CronExpression} as a copy of an existing
     * instance.
     *
     * @param expression
     *            The existing cron expression to be copied
     */
    public CronExpression(CronExpression expression) {
        /*
         * We don't call the other constructor here since we need to swallow the
         * ParseException. We also elide some of the sanity checking as it is
         * not logically trippable.
         */
        this.cronExpression = expression.getCronExpression();
        try {
            buildExpression(cronExpression);
        } catch (ParseException ex) {
            throw new AssertionError();
        }

        final TimeZone timeZone;
        if ((timeZone = expression.getTimeZone()) != null) {
            setTimeZone((TimeZone) timeZone.clone());
        }
    }

    /**
     * Indicates whether the given date satisfies the cron expression. Note that
     * milliseconds are ignored, so two Dates falling on different milliseconds
     * of the same second will always have the same result here.
     *
     * @param date the date to evaluate
     * @return a boolean indicating whether the given date satisfies the cron
     *         expression
     */
    public boolean isSatisfiedBy(Date date) {
        Calendar testDateCal = Calendar.getInstance(getTimeZone());
        testDateCal.setTime(date);
        testDateCal.set(Calendar.MILLISECOND, 0);
        Date originalDate = testDateCal.getTime();

        testDateCal.add(Calendar.SECOND, -1);

        Date timeAfter = getTimeAfter(testDateCal.getTime());

        return ((timeAfter != null) && (timeAfter.equals(originalDate)));
    }

    /**
     * Returns the next date/time after the given date/time which
     * satisfies the cron expression.
     *
     * @param date the date/time at which to begin the search for the next valid
     *             date/time
     * @return the next valid date/time
     */
    public Date getNextValidTimeAfter(Date date) {
        return getTimeAfter(date);
    }

    /**
     * Returns the next date/time after the given date/time which does
     * not satisfy the expression
     *
     * @param date the date/time at which to begin the search for the next
     *             invalid date/time
     * @return the next valid date/time
     */
    public Date getNextInvalidTimeAfter(Date date) {
        long difference = 1000;

        //move back to the nearest second so differences will be accurate
        Calendar adjustCal = Calendar.getInstance(getTimeZone());
        adjustCal.setTime(date);
        adjustCal.set(Calendar.MILLISECOND, 0);
        Date lastDate = adjustCal.getTime();

        Date newDate;

        //FUTURE_TODO: (QUARTZ-481) IMPROVE THIS! The following is a BAD solution to this problem. Performance will be very bad here, depending on the cron expression. It is, however A solution.

        //keep getting the next included time until it's farther than one second
        // apart. At that point, lastDate is the last valid fire time. We return
        // the second immediately following it.
        while (difference == 1000) {
            newDate = getTimeAfter(lastDate);
            if (newDate == null)
                break;

            difference = newDate.getTime() - lastDate.getTime();

            if (difference == 1000) {
                lastDate = newDate;
            }
        }

        return new Date(lastDate.getTime() + 1000);
    }

    /**
     * @return Returns the time zone for which this CronExpression
     * will be resolved.
     */
    public TimeZone getTimeZone() {
        if (timeZone == null) {
            timeZone = TimeZone.getDefault();
        }

        return timeZone;
    }

    /**
     * Sets the time zone for which  this CronExpression
     * will be resolved.
     * @param timeZone the timeZone
     */
    public void setTimeZone(TimeZone timeZone) {
        this.timeZone = timeZone;
    }

    /**
     * Returns the string representation of the CronExpression
     *
     * @return a string representation of the CronExpression
     */
    @Override
    public String toString() {
        return cronExpression;
    }

    /**
     * Indicates whether the specified cron expression can be parsed into a
     * valid cron expression
     *
     * @param cronExpression the expression to evaluate
     * @return a boolean indicating whether the given expression is a valid cron
     *         expression
     */
    public static boolean isValidExpression(String cronExpression) {

        try {
            new CronExpression(cronExpression);
        } catch (ParseException pe) {
            return false;
        }

        return true;
    }

    public static void validateExpression(String cronExpression) throws ParseException {

        new CronExpression(cronExpression);
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Expression Parsing Functions
    //
    ////////////////////////////////////////////////////////////////////////////

    protected void buildExpression(String expression) throws ParseException {
        expressionParsed = true;

        try {

            if (seconds == null) {
                seconds = new TreeSet<Integer>();
            }
            if (minutes == null) {
                minutes = new TreeSet<Integer>();
            }
            if (hours == null) {
                hours = new TreeSet<Integer>();
            }
            if (daysOfMonth == null) {
                daysOfMonth = new TreeSet<Integer>();
            }
            if (months == null) {
                months = new TreeSet<Integer>();
            }
            if (daysOfWeek == null) {
                daysOfWeek = new TreeSet<Integer>();
            }
            if (years == null) {
                years = new TreeSet<Integer>();
            }

            int exprOn = SECOND;

            StringTokenizer exprsTok = new StringTokenizer(expression, " \t", false);

            while (exprsTok.hasMoreTokens() && exprOn <= YEAR) {
                String expr = exprsTok.nextToken().trim();

                // throw an exception if L is used with other days of the month
                if (exprOn == DAY_OF_MONTH && expr.indexOf('L') != -1 && expr.length() > 1 && expr.contains(",")) {
                    throw new ParseException("Support for specifying 'L' and 'LW' with other days of the month is not implemented", -1);
                }
                // throw an exception if L is used with other days of the week
                if (exprOn == DAY_OF_WEEK && expr.indexOf('L') != -1 && expr.length() > 1 && expr.contains(",")) {
                    throw new ParseException("Support for specifying 'L' with other days of the week is not implemented", -1);
                }
                if (exprOn == DAY_OF_WEEK && expr.indexOf('#') != -1 && expr.indexOf('#', expr.indexOf('#') + 1) != -1) {
                    throw new ParseException("Support for specifying multiple \"nth\" days is not implemented.", -1);
                }

                StringTokenizer vTok = new StringTokenizer(expr, ",");
                while (vTok.hasMoreTokens()) {
                    String v = vTok.nextToken();
                    storeExpressionVals(0, v, exprOn);
                }

                exprOn++;
            }

            if (exprOn <= DAY_OF_WEEK) {
                throw new ParseException("Unexpected end of expression.", expression.length());
            }

            if (exprOn <= YEAR) {
                storeExpressionVals(0, "*", YEAR);
            }

            TreeSet<Integer> dow = getSet(DAY_OF_WEEK);
            TreeSet<Integer> dom = getSet(DAY_OF_MONTH);

            // Copying the logic from the UnsupportedOperationException below
            boolean dayOfMSpec = !dom.contains(NO_SPEC);
            boolean dayOfWSpec = !dow.contains(NO_SPEC);

            if (!dayOfMSpec || dayOfWSpec) {
                if (!dayOfWSpec || dayOfMSpec) {
                    throw new ParseException("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented.", 0);
                }
            }
        } catch (ParseException pe) {
            throw pe;
        } catch (Exception e) {
            throw new ParseException("Illegal cron expression format (" + e.toString() + ')', 0);
        }
    }

    protected int storeExpressionVals(int pos, String s, int type) throws ParseException {

        int incr = 0;
        int i = skipWhiteSpace(pos, s);
        if (i >= s.length()) {
            return i;
        }
        char c = s.charAt(i);
        if ((c >= 'A') && (c <= 'Z') && (!s.equals("L")) && (!s.equals("LW")) && (!s.matches("^L-[0-9]*[W]?"))) {
            String sub = s.substring(i, i + 3);
            int sval = -1;
            int eval = -1;
            if (type == MONTH) {
                sval = getMonthNumber(sub) + 1;
                if (sval <= 0) {
                    throw new ParseException("Invalid Month value: '" + sub + '\'', i);
                }
                if (s.length() > i + 3) {
                    c = s.charAt(i + 3);
                    if (c == '-') {
                        i += 4;
                        sub = s.substring(i, i + 3);
                        eval = getMonthNumber(sub) + 1;
                        if (eval <= 0) {
                            throw new ParseException("Invalid Month value: '" + sub + '\'', i);
                        }
                    }
                }
            } else if (type == DAY_OF_WEEK) {
                sval = getDayOfWeekNumber(sub);
                if (sval < 0) {
                    throw new ParseException("Invalid Day-of-Week value: '" + sub + '\'', i);
                }
                if (s.length() > i + 3) {
                    c = s.charAt(i + 3);
                    if (c == '-') {
                        i += 4;
                        sub = s.substring(i, i + 3);
                        eval = getDayOfWeekNumber(sub);
                        if (eval < 0) {
                            throw new ParseException("Invalid Day-of-Week value: '" + sub + '\'', i);
                        }
                    } else if (c == '#') {
                        try {
                            i += 4;
                            nthdayOfWeek = Integer.parseInt(s.substring(i));
                            if (nthdayOfWeek < 1 || nthdayOfWeek > 5) {
                                throw new Exception();
                            }
                        } catch (Exception e) {
                            throw new ParseException("A numeric value between 1 and 5 must follow the '#' option", i);
                        }
                    } else if (c == 'L') {
                        lastdayOfWeek = true;
                        i++;
                    }
                }

            } else {
                throw new ParseException("Illegal characters for this position: '" + sub + '\'', i);
            }
            if (eval != -1) {
                incr = 1;
            }
            addToSet(sval, eval, incr, type);
            return (i + 3);
        }

        if (c == '?') {
            i++;
            if ((i + 1) < s.length() && (s.charAt(i) != ' ' && s.charAt(i + 1) != '\t')) {
                throw new ParseException("Illegal character after '?': " + s.charAt(i), i);
            }
            if (type != DAY_OF_WEEK && type != DAY_OF_MONTH) {
                throw new ParseException("'?' can only be specfied for Day-of-Month or Day-of-Week.", i);
            }
            if (type == DAY_OF_WEEK && !lastdayOfMonth) {
                int val = daysOfMonth.last();
                if (val == NO_SPEC_INT) {
                    throw new ParseException("'?' can only be specfied for Day-of-Month -OR- Day-of-Week.", i);
                }
            }

            addToSet(NO_SPEC_INT, -1, 0, type);
            return i;
        }

        if (c == '*' || c == '/') {
            if (c == '*' && (i + 1) >= s.length()) {
                addToSet(ALL_SPEC_INT, -1, incr, type);
                return i + 1;
            } else if (c == '/' && ((i + 1) >= s.length() || s.charAt(i + 1) == ' ' || s.charAt(i + 1) == '\t')) {
                throw new ParseException("'/' must be followed by an integer.", i);
            } else if (c == '*') {
                i++;
            }
            c = s.charAt(i);
            if (c == '/') { // is an increment specified?
                i++;
                if (i >= s.length()) {
                    throw new ParseException("Unexpected end of string.", i);
                }

                incr = getNumericValue(s, i);

                i++;
                if (incr > 10) {
                    i++;
                }
                if (incr > 59 && (type == SECOND || type == MINUTE)) {
                    throw new ParseException("Increment > 60 : " + incr, i);
                } else if (incr > 23 && (type == HOUR)) {
                    throw new ParseException("Increment > 24 : " + incr, i);
                } else if (incr > 31 && (type == DAY_OF_MONTH)) {
                    throw new ParseException("Increment > 31 : " + incr, i);
                } else if (incr > 7 && (type == DAY_OF_WEEK)) {
                    throw new ParseException("Increment > 7 : " + incr, i);
                } else if (incr > 12 && (type == MONTH)) {
                    throw new ParseException("Increment > 12 : " + incr, i);
                }
            } else {
                incr = 1;
            }

            addToSet(ALL_SPEC_INT, -1, incr, type);
            return i;
        } else if (c == 'L') {
            i++;
            if (type == DAY_OF_MONTH) {
                lastdayOfMonth = true;
            }
            if (type == DAY_OF_WEEK) {
                addToSet(7, 7, 0, type);
            }
            if (type == DAY_OF_MONTH && s.length() > i) {
                c = s.charAt(i);
                if (c == '-') {
                    ValueSet vs = getValue(0, s, i + 1);
                    lastdayOffset = vs.value;
                    if (lastdayOffset > 30)
                        throw new ParseException("Offset from last day must be <= 30", i + 1);
                    i = vs.pos;
                }
                if (s.length() > i) {
                    c = s.charAt(i);
                    if (c == 'W') {
                        nearestWeekday = true;
                        i++;
                    }
                }
            }
            return i;
        } else if (c >= '0' && c <= '9') {
            int val = Integer.parseInt(String.valueOf(c));
            i++;
            if (i >= s.length()) {
                addToSet(val, -1, -1, type);
            } else {
                c = s.charAt(i);
                if (c >= '0' && c <= '9') {
                    ValueSet vs = getValue(val, s, i);
                    val = vs.value;
                    i = vs.pos;
                }
                i = checkNext(i, s, val, type);
                return i;
            }
        } else {
            throw new ParseException("Unexpected character: " + c, i);
        }

        return i;
    }

    protected int checkNext(int pos, String s, int val, int type) throws ParseException {

        int end = -1;
        int i = pos;

        if (i >= s.length()) {
            addToSet(val, end, -1, type);
            return i;
        }

        char c = s.charAt(pos);

        if (c == 'L') {
            if (type == DAY_OF_WEEK) {
                if (val < 1 || val > 7)
                    throw new ParseException("Day-of-Week values must be between 1 and 7", -1);
                lastdayOfWeek = true;
            } else {
                throw new ParseException("'L' option is not valid here. (pos=" + i + ')', i);
            }
            TreeSet<Integer> set = getSet(type);
            set.add(val);
            i++;
            return i;
        }

        if (c == 'W') {
            if (type == DAY_OF_MONTH) {
                nearestWeekday = true;
            } else {
                throw new ParseException("'W' option is not valid here. (pos=" + i + ')', i);
            }
            if (val > 31)
                throw new ParseException("The 'W' option does not make sense with values larger than 31 (max number of days in a month)", i);
            TreeSet<Integer> set = getSet(type);
            set.add(val);
            i++;
            return i;
        }

        if (c == '#') {
            if (type != DAY_OF_WEEK) {
                throw new ParseException("'#' option is not valid here. (pos=" + i + ')', i);
            }
            i++;
            try {
                nthdayOfWeek = Integer.parseInt(s.substring(i));
                if (nthdayOfWeek < 1 || nthdayOfWeek > 5) {
                    throw new Exception();
                }
            } catch (Exception e) {
                throw new ParseException("A numeric value between 1 and 5 must follow the '#' option", i);
            }

            TreeSet<Integer> set = getSet(type);
            set.add(val);
            i++;
            return i;
        }

        if (c == '-') {
            i++;
            c = s.charAt(i);
            int v = Integer.parseInt(String.valueOf(c));
            end = v;
            i++;
            if (i >= s.length()) {
                addToSet(val, end, 1, type);
                return i;
            }
            c = s.charAt(i);
            if (c >= '0' && c <= '9') {
                ValueSet vs = getValue(v, s, i);
                end = vs.value;
                i = vs.pos;
            }
            if (i < s.length() && ((c = s.charAt(i)) == '/')) {
                i++;
                c = s.charAt(i);
                int v2 = Integer.parseInt(String.valueOf(c));
                i++;
                if (i >= s.length()) {
                    addToSet(val, end, v2, type);
                    return i;
                }
                c = s.charAt(i);
                if (c >= '0' && c <= '9') {
                    ValueSet vs = getValue(v2, s, i);
                    int v3 = vs.value;
                    addToSet(val, end, v3, type);
                    i = vs.pos;
                    return i;
                } else {
                    addToSet(val, end, v2, type);
                    return i;
                }
            } else {
                addToSet(val, end, 1, type);
                return i;
            }
        }

        if (c == '/') {
            i++;
            c = s.charAt(i);
            int v2 = Integer.parseInt(String.valueOf(c));
            i++;
            if (i >= s.length()) {
                addToSet(val, end, v2, type);
                return i;
            }
            c = s.charAt(i);
            if (c >= '0' && c <= '9') {
                ValueSet vs = getValue(v2, s, i);
                int v3 = vs.value;
                addToSet(val, end, v3, type);
                i = vs.pos;
                return i;
            } else {
                throw new ParseException("Unexpected character '" + c + "' after '/'", i);
            }
        }

        addToSet(val, end, 0, type);
        i++;
        return i;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public String getExpressionSummary() {
        StringBuilder buf = new StringBuilder();

        buf.append("seconds: ");
        buf.append(getExpressionSetSummary(seconds));
        buf.append('\n');
        buf.append("minutes: ");
        buf.append(getExpressionSetSummary(minutes));
        buf.append('\n');
        buf.append("hours: ");
        buf.append(getExpressionSetSummary(hours));
        buf.append('\n');
        buf.append("daysOfMonth: ");
        buf.append(getExpressionSetSummary(daysOfMonth));
        buf.append('\n');
        buf.append("months: ");
        buf.append(getExpressionSetSummary(months));
        buf.append('\n');
        buf.append("daysOfWeek: ");
        buf.append(getExpressionSetSummary(daysOfWeek));
        buf.append('\n');
        buf.append("lastdayOfWeek: ");
        buf.append(lastdayOfWeek);
        buf.append('\n');
        buf.append("nearestWeekday: ");
        buf.append(nearestWeekday);
        buf.append('\n');
        buf.append("NthDayOfWeek: ");
        buf.append(nthdayOfWeek);
        buf.append('\n');
        buf.append("lastdayOfMonth: ");
        buf.append(lastdayOfMonth);
        buf.append('\n');
        buf.append("years: ");
        buf.append(getExpressionSetSummary(years));
        buf.append('\n');

        return buf.toString();
    }

    protected String getExpressionSetSummary(java.util.Set<Integer> set) {

        if (set.contains(NO_SPEC)) {
            return "?";
        }
        if (set.contains(ALL_SPEC)) {
            return "*";
        }

        StringBuilder buf = new StringBuilder();

        Iterator<Integer> itr = set.iterator();
        boolean first = true;
        while (itr.hasNext()) {
            Integer iVal = itr.next();
            String val = iVal.toString();
            if (!first) {
                buf.append(',');
            }
            buf.append(val);
            first = false;
        }

        return buf.toString();
    }

    protected String getExpressionSetSummary(java.util.ArrayList<Integer> list) {

        if (list.contains(NO_SPEC)) {
            return "?";
        }
        if (list.contains(ALL_SPEC)) {
            return "*";
        }

        StringBuilder buf = new StringBuilder();

        Iterator<Integer> itr = list.iterator();
        boolean first = true;
        while (itr.hasNext()) {
            Integer iVal = itr.next();
            String val = iVal.toString();
            if (!first) {
                buf.append(',');
            }
            buf.append(val);
            first = false;
        }

        return buf.toString();
    }

    protected int skipWhiteSpace(int i, String s) {
        for (; i < s.length() && (s.charAt(i) == ' ' || s.charAt(i) == '\t'); i++) {
            ;
        }

        return i;
    }

    protected int findNextWhiteSpace(int i, String s) {
        for (; i < s.length() && (s.charAt(i) != ' ' || s.charAt(i) != '\t'); i++) {
            ;
        }

        return i;
    }

    protected void addToSet(int val, int end, int incr, int type) throws ParseException {

        TreeSet<Integer> set = getSet(type);

        if (type == SECOND || type == MINUTE) {
            if ((val < 0 || val > 59 || end > 59) && (val != ALL_SPEC_INT)) {
                throw new ParseException("Minute and Second values must be between 0 and 59", -1);
            }
        } else if (type == HOUR) {
            if ((val < 0 || val > 23 || end > 23) && (val != ALL_SPEC_INT)) {
                throw new ParseException("Hour values must be between 0 and 23", -1);
            }
        } else if (type == DAY_OF_MONTH) {
            if ((val < 1 || val > 31 || end > 31) && (val != ALL_SPEC_INT) && (val != NO_SPEC_INT)) {
                throw new ParseException("Day of month values must be between 1 and 31", -1);
            }
        } else if (type == MONTH) {
            if ((val < 1 || val > 12 || end > 12) && (val != ALL_SPEC_INT)) {
                throw new ParseException("Month values must be between 1 and 12", -1);
            }
        } else if (type == DAY_OF_WEEK) {
            if ((val == 0 || val > 7 || end > 7) && (val != ALL_SPEC_INT) && (val != NO_SPEC_INT)) {
                throw new ParseException("Day-of-Week values must be between 1 and 7", -1);
            }
        }

        if ((incr == 0 || incr == -1) && val != ALL_SPEC_INT) {
            if (val != -1) {
                set.add(val);
            } else {
                set.add(NO_SPEC);
            }

            return;
        }

        int startAt = val;
        int stopAt = end;

        if (val == ALL_SPEC_INT && incr <= 0) {
            incr = 1;
            set.add(ALL_SPEC); // put in a marker, but also fill values
        }

        if (type == SECOND || type == MINUTE) {
            if (stopAt == -1) {
                stopAt = 59;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 0;
            }
        } else if (type == HOUR) {
            if (stopAt == -1) {
                stopAt = 23;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 0;
            }
        } else if (type == DAY_OF_MONTH) {
            if (stopAt == -1) {
                stopAt = 31;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 1;
            }
        } else if (type == MONTH) {
            if (stopAt == -1) {
                stopAt = 12;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 1;
            }
        } else if (type == DAY_OF_WEEK) {
            if (stopAt == -1) {
                stopAt = 7;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 1;
            }
        } else if (type == YEAR) {
            if (stopAt == -1) {
                stopAt = MAX_YEAR;
            }
            if (startAt == -1 || startAt == ALL_SPEC_INT) {
                startAt = 1970;
            }
        }

        // if the end of the range is before the start, then we need to overflow into
        // the next day, month etc. This is done by adding the maximum amount for that
        // type, and using modulus max to determine the value being added.
        int max = -1;
        if (stopAt < startAt) {
            switch (type) {
                case SECOND:
                    max = 60;
                    break;
                case MINUTE:
                    max = 60;
                    break;
                case HOUR:
                    max = 24;
                    break;
                case MONTH:
                    max = 12;
                    break;
                case DAY_OF_WEEK:
                    max = 7;
                    break;
                case DAY_OF_MONTH:
                    max = 31;
                    break;
                case YEAR:
                    throw new IllegalArgumentException("Start year must be less than stop year");
                default:
                    throw new IllegalArgumentException("Unexpected type encountered");
            }
            stopAt += max;
        }

        for (int i = startAt; i <= stopAt; i += incr) {
            if (max == -1) {
                // ie: there's no max to overflow over
                set.add(i);
            } else {
                // take the modulus to get the real value
                int i2 = i % max;

                // 1-indexed ranges should not include 0, and should include their max
                if (i2 == 0 && (type == MONTH || type == DAY_OF_WEEK || type == DAY_OF_MONTH)) {
                    i2 = max;
                }

                set.add(i2);
            }
        }
    }

    TreeSet<Integer> getSet(int type) {
        switch (type) {
            case SECOND:
                return seconds;
            case MINUTE:
                return minutes;
            case HOUR:
                return hours;
            case DAY_OF_MONTH:
                return daysOfMonth;
            case MONTH:
                return months;
            case DAY_OF_WEEK:
                return daysOfWeek;
            case YEAR:
                return years;
            default:
                return null;
        }
    }

    protected ValueSet getValue(int v, String s, int i) {
        char c = s.charAt(i);
        StringBuilder s1 = new StringBuilder(String.valueOf(v));
        while (c >= '0' && c <= '9') {
            s1.append(c);
            i++;
            if (i >= s.length()) {
                break;
            }
            c = s.charAt(i);
        }
        ValueSet val = new ValueSet();

        val.pos = (i < s.length()) ? i : i + 1;
        val.value = Integer.parseInt(s1.toString());
        return val;
    }

    protected int getNumericValue(String s, int i) {
        int endOfVal = findNextWhiteSpace(i, s);
        String val = s.substring(i, endOfVal);
        return Integer.parseInt(val);
    }

    protected int getMonthNumber(String s) {
        Integer integer = monthMap.get(s);

        if (integer == null) {
            return -1;
        }

        return integer;
    }

    protected int getDayOfWeekNumber(String s) {
        Integer integer = dayMap.get(s);

        if (integer == null) {
            return -1;
        }

        return integer;
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Computation Functions
    //
    ////////////////////////////////////////////////////////////////////////////

    public Date getTimeAfter(Date afterTime) {

        // Computation is based on Gregorian year only.
        Calendar cl = new java.util.GregorianCalendar(getTimeZone());

        // move ahead one second, since we're computing the time *after* the
        // given time
        afterTime = new Date(afterTime.getTime() + 1000);
        // CronTrigger does not deal with milliseconds
        cl.setTime(afterTime);
        cl.set(Calendar.MILLISECOND, 0);

        boolean gotOne = false;
        // loop until we've computed the next time, or we've past the endTime
        while (!gotOne) {

            //if (endTime != null && cl.getTime().after(endTime)) return null;
            if (cl.get(Calendar.YEAR) > 2999) { // prevent endless loop...
                return null;
            }

            SortedSet<Integer> st = null;
            int t = 0;

            int sec = cl.get(Calendar.SECOND);
            int min = cl.get(Calendar.MINUTE);

            // get second.................................................
            st = seconds.tailSet(sec);
            if (st != null && st.size() != 0) {
                sec = st.first();
            } else {
                sec = seconds.first();
                min++;
                cl.set(Calendar.MINUTE, min);
            }
            cl.set(Calendar.SECOND, sec);

            min = cl.get(Calendar.MINUTE);
            int hr = cl.get(Calendar.HOUR_OF_DAY);
            t = -1;

            // get minute.................................................
            st = minutes.tailSet(min);
            if (st != null && st.size() != 0) {
                t = min;
                min = st.first();
            } else {
                min = minutes.first();
                hr++;
            }
            if (min != t) {
                cl.set(Calendar.SECOND, 0);
                cl.set(Calendar.MINUTE, min);
                setCalendarHour(cl, hr);
                continue;
            }
            cl.set(Calendar.MINUTE, min);

            hr = cl.get(Calendar.HOUR_OF_DAY);
            int day = cl.get(Calendar.DAY_OF_MONTH);
            t = -1;

            // get hour...................................................
            st = hours.tailSet(hr);
            if (st != null && st.size() != 0) {
                t = hr;
                hr = st.first();
            } else {
                hr = hours.first();
                day++;
            }
            if (hr != t) {
                cl.set(Calendar.SECOND, 0);
                cl.set(Calendar.MINUTE, 0);
                cl.set(Calendar.DAY_OF_MONTH, day);
                setCalendarHour(cl, hr);
                continue;
            }
            cl.set(Calendar.HOUR_OF_DAY, hr);

            day = cl.get(Calendar.DAY_OF_MONTH);
            int mon = cl.get(Calendar.MONTH) + 1;
            // '+ 1' because calendar is 0-based for this field, and we are
            // 1-based
            t = -1;
            int tmon = mon;

            // get day...................................................
            boolean dayOfMSpec = !daysOfMonth.contains(NO_SPEC);
            boolean dayOfWSpec = !daysOfWeek.contains(NO_SPEC);
            if (dayOfMSpec && !dayOfWSpec) { // get day by day of month rule
                st = daysOfMonth.tailSet(day);
                if (lastdayOfMonth) {
                    if (!nearestWeekday) {
                        t = day;
                        day = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                        day -= lastdayOffset;
                        if (t > day) {
                            mon++;
                            if (mon > 12) {
                                mon = 1;
                                tmon = 3333; // ensure test of mon != tmon further below fails
                                cl.add(Calendar.YEAR, 1);
                            }
                            day = 1;
                        }
                    } else {
                        t = day;
                        day = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                        day -= lastdayOffset;

                        java.util.Calendar tcal = java.util.Calendar.getInstance(getTimeZone());
                        tcal.set(Calendar.SECOND, 0);
                        tcal.set(Calendar.MINUTE, 0);
                        tcal.set(Calendar.HOUR_OF_DAY, 0);
                        tcal.set(Calendar.DAY_OF_MONTH, day);
                        tcal.set(Calendar.MONTH, mon - 1);
                        tcal.set(Calendar.YEAR, cl.get(Calendar.YEAR));

                        int ldom = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                        int dow = tcal.get(Calendar.DAY_OF_WEEK);

                        if (dow == Calendar.SATURDAY && day == 1) {
                            day += 2;
                        } else if (dow == Calendar.SATURDAY) {
                            day -= 1;
                        } else if (dow == Calendar.SUNDAY && day == ldom) {
                            day -= 2;
                        } else if (dow == Calendar.SUNDAY) {
                            day += 1;
                        }

                        tcal.set(Calendar.SECOND, sec);
                        tcal.set(Calendar.MINUTE, min);
                        tcal.set(Calendar.HOUR_OF_DAY, hr);
                        tcal.set(Calendar.DAY_OF_MONTH, day);
                        tcal.set(Calendar.MONTH, mon - 1);
                        Date nTime = tcal.getTime();
                        if (nTime.before(afterTime)) {
                            day = 1;
                            mon++;
                        }
                    }
                } else if (nearestWeekday) {
                    t = day;
                    day = daysOfMonth.first();

                    java.util.Calendar tcal = java.util.Calendar.getInstance(getTimeZone());
                    tcal.set(Calendar.SECOND, 0);
                    tcal.set(Calendar.MINUTE, 0);
                    tcal.set(Calendar.HOUR_OF_DAY, 0);
                    tcal.set(Calendar.DAY_OF_MONTH, day);
                    tcal.set(Calendar.MONTH, mon - 1);
                    tcal.set(Calendar.YEAR, cl.get(Calendar.YEAR));

                    int ldom = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                    int dow = tcal.get(Calendar.DAY_OF_WEEK);

                    if (dow == Calendar.SATURDAY && day == 1) {
                        day += 2;
                    } else if (dow == Calendar.SATURDAY) {
                        day -= 1;
                    } else if (dow == Calendar.SUNDAY && day == ldom) {
                        day -= 2;
                    } else if (dow == Calendar.SUNDAY) {
                        day += 1;
                    }

                    tcal.set(Calendar.SECOND, sec);
                    tcal.set(Calendar.MINUTE, min);
                    tcal.set(Calendar.HOUR_OF_DAY, hr);
                    tcal.set(Calendar.DAY_OF_MONTH, day);
                    tcal.set(Calendar.MONTH, mon - 1);
                    Date nTime = tcal.getTime();
                    if (nTime.before(afterTime)) {
                        day = daysOfMonth.first();
                        mon++;
                    }
                } else if (st != null && st.size() != 0) {
                    t = day;
                    day = st.first();
                    // make sure we don't over-run a short month, such as february
                    int lastDay = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
                    if (day > lastDay) {
                        day = daysOfMonth.first();
                        mon++;
                    }
                } else {
                    day = daysOfMonth.first();
                    mon++;
                }

                if (day != t || mon != tmon) {
                    cl.set(Calendar.SECOND, 0);
                    cl.set(Calendar.MINUTE, 0);
                    cl.set(Calendar.HOUR_OF_DAY, 0);
                    cl.set(Calendar.DAY_OF_MONTH, day);
                    cl.set(Calendar.MONTH, mon - 1);
                    // '- 1' because calendar is 0-based for this field, and we
                    // are 1-based
                    continue;
                }
            } else if (dayOfWSpec && !dayOfMSpec) { // get day by day of week rule
                if (lastdayOfWeek) { // are we looking for the last XXX day of
                    // the month?
                    int dow = daysOfWeek.first(); // desired
                    // d-o-w
                    int cDow = cl.get(Calendar.DAY_OF_WEEK); // current d-o-w
                    int daysToAdd = 0;
                    if (cDow < dow) {
                        daysToAdd = dow - cDow;
                    }
                    if (cDow > dow) {
                        daysToAdd = dow + (7 - cDow);
                    }

                    int lDay = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));

                    if (day + daysToAdd > lDay) { // did we already miss the
                        // last one?
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, 1);
                        cl.set(Calendar.MONTH, mon);
                        // no '- 1' here because we are promoting the month
                        continue;
                    }

                    // find date of last occurrence of this day in this month...
                    while ((day + daysToAdd + 7) <= lDay) {
                        daysToAdd += 7;
                    }

                    day += daysToAdd;

                    if (daysToAdd > 0) {
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, day);
                        cl.set(Calendar.MONTH, mon - 1);
                        // '- 1' here because we are not promoting the month
                        continue;
                    }

                } else if (nthdayOfWeek != 0) {
                    // are we looking for the Nth XXX day in the month?
                    int dow = daysOfWeek.first(); // desired
                    // d-o-w
                    int cDow = cl.get(Calendar.DAY_OF_WEEK); // current d-o-w
                    int daysToAdd = 0;
                    if (cDow < dow) {
                        daysToAdd = dow - cDow;
                    } else if (cDow > dow) {
                        daysToAdd = dow + (7 - cDow);
                    }

                    boolean dayShifted = false;
                    if (daysToAdd > 0) {
                        dayShifted = true;
                    }

                    day += daysToAdd;
                    int weekOfMonth = day / 7;
                    if (day % 7 > 0) {
                        weekOfMonth++;
                    }

                    daysToAdd = (nthdayOfWeek - weekOfMonth) * 7;
                    day += daysToAdd;
                    if (daysToAdd < 0 || day > getLastDayOfMonth(mon, cl.get(Calendar.YEAR))) {
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, 1);
                        cl.set(Calendar.MONTH, mon);
                        // no '- 1' here because we are promoting the month
                        continue;
                    } else if (daysToAdd > 0 || dayShifted) {
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, day);
                        cl.set(Calendar.MONTH, mon - 1);
                        // '- 1' here because we are NOT promoting the month
                        continue;
                    }
                } else {
                    int cDow = cl.get(Calendar.DAY_OF_WEEK); // current d-o-w
                    int dow = daysOfWeek.first(); // desired
                    // d-o-w
                    st = daysOfWeek.tailSet(cDow);
                    if (st != null && st.size() > 0) {
                        dow = st.first();
                    }

                    int daysToAdd = 0;
                    if (cDow < dow) {
                        daysToAdd = dow - cDow;
                    }
                    if (cDow > dow) {
                        daysToAdd = dow + (7 - cDow);
                    }

                    int lDay = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));

                    if (day + daysToAdd > lDay) { // will we pass the end of
                        // the month?
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, 1);
                        cl.set(Calendar.MONTH, mon);
                        // no '- 1' here because we are promoting the month
                        continue;
                    } else if (daysToAdd > 0) { // are we swithing days?
                        cl.set(Calendar.SECOND, 0);
                        cl.set(Calendar.MINUTE, 0);
                        cl.set(Calendar.HOUR_OF_DAY, 0);
                        cl.set(Calendar.DAY_OF_MONTH, day + daysToAdd);
                        cl.set(Calendar.MONTH, mon - 1);
                        // '- 1' because calendar is 0-based for this field,
                        // and we are 1-based
                        continue;
                    }
                }
            } else { // dayOfWSpec && !dayOfMSpec
                throw new UnsupportedOperationException("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented.");
            }
            cl.set(Calendar.DAY_OF_MONTH, day);

            mon = cl.get(Calendar.MONTH) + 1;
            // '+ 1' because calendar is 0-based for this field, and we are
            // 1-based
            int year = cl.get(Calendar.YEAR);
            t = -1;

            // test for expressions that never generate a valid fire date,
            // but keep looping...
            if (year > MAX_YEAR) {
                return null;
            }

            // get month...................................................
            st = months.tailSet(mon);
            if (st != null && st.size() != 0) {
                t = mon;
                mon = st.first();
            } else {
                mon = months.first();
                year++;
            }
            if (mon != t) {
                cl.set(Calendar.SECOND, 0);
                cl.set(Calendar.MINUTE, 0);
                cl.set(Calendar.HOUR_OF_DAY, 0);
                cl.set(Calendar.DAY_OF_MONTH, 1);
                cl.set(Calendar.MONTH, mon - 1);
                // '- 1' because calendar is 0-based for this field, and we are
                // 1-based
                cl.set(Calendar.YEAR, year);
                continue;
            }
            cl.set(Calendar.MONTH, mon - 1);
            // '- 1' because calendar is 0-based for this field, and we are
            // 1-based

            year = cl.get(Calendar.YEAR);
            t = -1;

            // get year...................................................
            st = years.tailSet(year);
            if (st != null && st.size() != 0) {
                t = year;
                year = st.first();
            } else {
                return null; // ran out of years...
            }

            if (year != t) {
                cl.set(Calendar.SECOND, 0);
                cl.set(Calendar.MINUTE, 0);
                cl.set(Calendar.HOUR_OF_DAY, 0);
                cl.set(Calendar.DAY_OF_MONTH, 1);
                cl.set(Calendar.MONTH, 0);
                // '- 1' because calendar is 0-based for this field, and we are
                // 1-based
                cl.set(Calendar.YEAR, year);
                continue;
            }
            cl.set(Calendar.YEAR, year);

            gotOne = true;
        } // while( !done )

        return cl.getTime();
    }

    /**
     * Advance the calendar to the particular hour paying particular attention
     * to daylight saving problems.
     *
     * @param cal the calendar to operate on
     * @param hour the hour to set
     */
    protected void setCalendarHour(Calendar cal, int hour) {
        cal.set(java.util.Calendar.HOUR_OF_DAY, hour);
        if (cal.get(java.util.Calendar.HOUR_OF_DAY) != hour && hour != 24) {
            cal.set(java.util.Calendar.HOUR_OF_DAY, hour + 1);
        }
    }

    /**
     * NOT YET IMPLEMENTED: Returns the time before the given time
     * that the CronExpression matches.
     * @param endTime the endTime
     * @return Returns the time before the given time that the CronExpression matches.
     */
    public Date getTimeBefore(Date endTime) {
        // FUTURE_TODO: implement QUARTZ-423
        return null;
    }

    /**
     * NOT YET IMPLEMENTED: Returns the final time that the
     * CronExpression will match.
     * @return Returns the final time that the CronExpression will match
     */
    public Date getFinalFireTime() {
        // FUTURE_TODO: implement QUARTZ-423
        return null;
    }

    protected boolean isLeapYear(int year) {
        return ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
    }

    protected int getLastDayOfMonth(int monthNum, int year) {

        switch (monthNum) {
            case 1:
                return 31;
            case 2:
                return (isLeapYear(year)) ? 29 : 28;
            case 3:
                return 31;
            case 4:
                return 30;
            case 5:
                return 31;
            case 6:
                return 30;
            case 7:
                return 31;
            case 8:
                return 31;
            case 9:
                return 30;
            case 10:
                return 31;
            case 11:
                return 30;
            case 12:
                return 31;
            default:
                throw new IllegalArgumentException("Illegal month number: " + monthNum);
        }
    }

    private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {

        stream.defaultReadObject();
        try {
            buildExpression(cronExpression);
        } catch (Exception ignore) {
        } // never happens
    }

    @Override
    @Deprecated
    public Object clone() {
        return new CronExpression(this);
    }
}

class ValueSet {
    public int value;

    public int pos;
}


text:
/*
 * $Id: SpontaneousMutation.java,v 1.11 2007-10-31 16:10:05 pandyas Exp $
 *
 * $Log: not supported by cvs2svn $
 * Revision 1.10  2006/05/04 19:28:24  pandyas
 * Changed GeneticAlterationCollection to GeneticAlteration relationship from SpontaneousMutation and InducedMutation objects
 *
 * Revision 1.9  2006/04/19 17:37:37  pandyas
 * Removed TODO text
 *
 * Revision 1.8  2006/04/17 19:13:46  pandyas
 * caMod 2.1 OM changes and added log/id header
 *
 */
package gov.nih.nci.camod.domain;

import java.io.Serializable;
import gov.nih.nci.camod.util.Duplicatable;
import gov.nih.nci.camod.util.HashCodeUtil;
import gov.nih.nci.camod.util.SafeHTMLUtil;

/**
 * @author rajputs
 */
public class SpontaneousMutation extends BaseObject implements Comparable, Serializable, Duplicatable
{
    private static final long serialVersionUID = 3258605453799404851L;

    private AbstractCancerModel cancerModel;
    private String name;
    private GeneIdentifier geneIdentifier;
    private String comments;
    private GeneticAlteration geneticAlteration;
    private MutationIdentifier mutationIdentifier;

    /**
     * @return Returns the cancerModel.
     */
    public AbstractCancerModel getCancerModel()
    {
        return cancerModel;
    }

    /**
     * @param cancerModel
     *            The cancerModel to set.
     */
    public void setCancerModel(AbstractCancerModel cancerModel)
    {
        this.cancerModel = cancerModel;
    }
    /**
     * @return Returns the name.
     */
    public String getName()
    {
        return SafeHTMLUtil.cleanMinimal(name);
    }

    /**
     * @param name
     *            The name to set.
     */
    public void setName(String name)
    {
        this.name = name;
    }

    /**
     * @return Returns the comments. Comment is a reserved word so
     * we must use the plural form comments.
     */
    public String getComments()
    {
        return SafeHTMLUtil.cleanMinimal(comments);
    }

    /**
     * @param comments
     *            The comments to set.
     */
    public void setComments(String comments)
    {
        this.comments = comments;
    }

    /**
     * @return Returns the geneticAlteration.
     */
    public GeneticAlteration getGeneticAlteration() {
        return geneticAlteration;
    }

    /**
     * @param geneticAlteration
     *            The geneticAlteration to set.
     */
    public void setGeneticAlteration(GeneticAlteration geneticAlteration) {
        this.geneticAlteration = geneticAlteration;
    }

    /**
     * @return Returns the mutationIdentifier.
     */
    public MutationIdentifier getMutationIdentifier()
    {
        return mutationIdentifier;
    }

    /**
     * @param mutationIdentifier
     *            The mutationIdentifier to set.
     */
    public void setMutationIdentifier(MutationIdentifier mutationIdentifier)
    {
        this.mutationIdentifier = mutationIdentifier;
    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString()
    {
        String result = super.toString() + " - ";
        result += this.getName();
        return result;
    }

    public boolean equals(Object o)
    {
        if (!super.equals(o))
            return false;
        if (!(this.getClass().isInstance(o)))
            return false;
        final SpontaneousMutation obj = (SpontaneousMutation) o;
        if (HashCodeUtil.notEqual(this.getName(), obj.getName()))
            return false;
        return true;
    }

    public int hashCode()
    {
        int result = HashCodeUtil.SEED;
        result = HashCodeUtil.hash(result, this.getName());
        return result + super.hashCode();
    }

    public int compareTo(Object o)
    {
        if ((o instanceof SpontaneousMutation) && (this.getName() != null) && (((SpontaneousMutation) o).getName() != null))
        {
            int result = this.getName().compareTo(((SpontaneousMutation) o).getName());
            if (result != 0)
            {
                return result;
            }
        }

        return super.compareTo(o);
    }

	/**
	 * @return the geneIdentifier
	 */
	public GeneIdentifier getGeneIdentifier() {
		return geneIdentifier;
	}

	/**
	 * @param geneIdentifier the geneIdentifier to set
	 */
	public void setGeneIdentifier(GeneIdentifier geneIdentifier) {
		this.geneIdentifier = geneIdentifier;
	}
}


text:
<!--
    Please leave this section at the top of the change log.

    Changes for the current release should go under the section titled "Current Release", and should adhere to the following format:

    ## Current Release
    * Overview of change #1
        - Additional information about change #1
    * Overview of change #2
        - Additional information about change #2
        - Additional information about change #2
    * Overview of change #3
    * Overview of change #4
        - Additional information about change #4

    ## YYYY.MM.DD - Version X.Y.Z (Previous Release)
    * Overview of change #1
        - Additional information about change #1
-->
## Current Release
* Added Location Completer to -Location parameters allowing tab completion through valid Locations
* Added ResourceGroup Completer to -ResourceGroup parameters allowing tab completion through resource groups in current subscription
* Obsoleted -Tags in favor of -Tag for Set-AzureRmAutomationRunbook

## Version 4.1.1
* Update to Import-AzureRMAutomationRunbook
    - Support is now being provided for Python2 runbooks

## Version 4.0.0
* Add support for online help
    - Run Get-Help with the -Online parameter to open the online help in your default Internet browser

## Version 3.4.1

## Version 3.4.0
* Fixed help documents for cmdlets fixed in the earlier release.
* Added 3 new cmdlets to support staged rollout of DSC node configurations.
	- Start-AzureRmAutomationDscNodeConfigurationDeployment
	- Stop-AzureRmAutomationDscNodeConfigurationDeployment
	- Get-AzureRmAutomationDscNodeConfigurationDeployment
	- Get-AzureRmAutomationDscNodeConfigurationDeploymentSchedule

## Version 3.3.1

## Version 3.3.0
* Made changes to AutomationDSC* cmdlets to pull more than 100 records
* Resolved the issue where the Verbose streams stop working after calling some Automation cmdlets (for example Get-AzureRmAutomationVariable, Get-AzureRmAutomationJob).
* Support for NodeConfiguration Build versioning added in StartAzureAutomationDscCompilationJob and ImportAzureAutomationDscNodeConfiguration.
* Bug fixes for existing issues - Fixes the alias issue is #3775 and the runOn alias and support for HybridWorkers.

## Version 3.2.1

## Version 3.2.0
* Properly setting TimeZone value for Weekly and Monthly schedules for New-AzureRmAutomationSchedule
    - More information can be found in this issue: https://github.com/Azure/azure-powershell/issues/3043

## Version 3.1.0

## Version 3.0.1

## Version 3.0.0

## Version 2.8.0

## Version 2.7.0

## Version 2.6.0

## Version 2.5.0

## Version 2.4.0

## Version 2.3.0