text:
"use strict";

var referee = require("@sinonjs/referee");
var sinon = require("../../lib/sinon");
var createStub = require("../../lib/sinon/stub");
var assert = referee.assert;
var refute = referee.refute;
var globalXHR = global.XMLHttpRequest;
var globalAXO = global.ActiveXObject;

describe("issues", function() {
    beforeEach(function() {
        this.sandbox = sinon.createSandbox();
    });

    afterEach(function() {
        this.sandbox.restore();
    });

    it("#283", function() {
        function testSinonFakeTimersWith(interval, ticks) {
            var clock = sinon.useFakeTimers();

            var spy = sinon.spy();
            var id = setInterval(spy, interval);
            assert(!spy.calledOnce);
            clock.tick(ticks);
            assert(spy.callCount === Math.floor(ticks / interval));

            clearInterval(id);
            clock.restore();
        }

        testSinonFakeTimersWith(10, 101);
        testSinonFakeTimersWith(99, 101);
        testSinonFakeTimersWith(100, 200);
        testSinonFakeTimersWith(199, 200);
        testSinonFakeTimersWith(500, 1001);
        testSinonFakeTimersWith(1000, 1001);
    });

    describe("#458", function() {
        if (typeof require("fs").readFileSync !== "undefined") {
            describe("on node", function() {
                it("stub out fs.readFileSync", function() {
                    var fs = require("fs");
                    var testCase = this;

                    refute.exception(function() {
                        testCase.sandbox.stub(fs, "readFileSync");
                    });
                });
            });
        }
    });

    describe("#624", function() {
        // eslint-disable-next-line mocha/no-skipped-tests
        it.skip("useFakeTimers should be idempotent", function() {
            // Issue #624 shows that useFakeTimers is not idempotent when it comes to
            // using Date.now
            // This test verifies that it's working, at least for Date.now
            var clock;

            clock = sinon.useFakeTimers(new Date("2014-12-29").getTime());
            assert.equals(clock.now, Date.now());

            clock = sinon.useFakeTimers(new Date("2015-12-15").getTime());
            assert.equals(clock.now, Date.now());

            clock = sinon.useFakeTimers(new Date("2015-1-5").getTime());
            assert.equals(clock.now, Date.now());
        });
    });

    describe("#852 - createStubInstance on intherited constructors", function() {
        it("must not throw error", function() {
            var A = function() {
                return;
            };
            var B = function() {
                return;
            };

            B.prototype = Object.create(A.prototype);
            B.prototype.constructor = A;

            refute.exception(function() {
                sinon.createStubInstance(B);
            });
        });
    });

    describe("#852(2) - createStubInstance should on same constructor", function() {
        it("must be idempotent", function() {
            var A = function() {
                return;
            };
            refute.exception(function() {
                sinon.createStubInstance(A);
                sinon.createStubInstance(A);
            });
        });
    });

    describe("#950 - first execution of a spy as a method renames that spy", function() {
        function bob() {
            return;
        }

        // IE 11 does not support the function name property
        if (bob.name) {
            it("should not rename spies", function() {
                var nameDescriptor = Object.getOwnPropertyDescriptor(bob, "name");
                var expectedName = nameDescriptor && nameDescriptor.configurable ? "bob" : "proxy";
                var spy = sinon.spy(bob);

                assert.equals(spy.name, expectedName);

                var obj = { methodName: spy };
                assert.equals(spy.name, expectedName);

                spy();
                assert.equals(spy.name, expectedName);

                obj.methodName.call(null);
                assert.equals(spy.name, expectedName);

                obj.methodName();
                assert.equals(spy.name, expectedName);

                obj.otherProp = spy;
                obj.otherProp();
                assert.equals(spy.name, expectedName);
            });
        }
    });

    describe("#1026", function() {
        it("should stub `watch` method on any Object", function() {
            // makes sure that Object.prototype.watch is set back to its old value
            function restore(oldWatch) {
                if (oldWatch) {
                    Object.prototype.watch = oldWatch; // eslint-disable-line no-extend-native
                } else {
                    delete Object.prototype.watch;
                }
            }

            var oldWatch;

            // eslint-disable-next-line no-restricted-syntax
            try {
                oldWatch = Object.prototype.watch;

                if (typeof Object.prototype.watch !== "function") {
                    // eslint-disable-next-line no-extend-native
                    Object.prototype.watch = function rolex() {
                        return;
                    };
                }

                var stubbedObject = sinon.stub({
                    watch: function() {
                        return;
                    }
                });

                stubbedObject.watch();

                assert.isArray(stubbedObject.watch.args);
            } catch (error) {
                restore(oldWatch);
                throw error;
            }

            restore(oldWatch);
        });
    });

    describe("#1154", function() {
        it("Ensures different matchers will not be tested against each other", function() {
            var match = sinon.match;
            var stub = sinon.stub;
            var readFile = stub();

            function endsWith(str, suffix) {
                return str.indexOf(suffix) + suffix.length === str.length;
            }

            function suffixA(fileName) {
                return endsWith(fileName, "suffixa");
            }

            function suffixB(fileName) {
                return endsWith(fileName, "suffixb");
            }

            var argsA = match(suffixA);
            var argsB = match(suffixB);

            var firstFake = readFile.withArgs(argsA);

            var secondFake = readFile.withArgs(argsB);

            assert(firstFake !== secondFake);
        });
    });

    describe("#1372 - sandbox.resetHistory", function() {
        it("should reset spies", function() {
            var spy = this.sandbox.spy();

            spy();
            assert.equals(spy.callCount, 1);

            spy();
            assert.equals(spy.callCount, 2);

            this.sandbox.resetHistory();

            spy();
            assert.equals(spy.callCount, 1); // should not fail but fails
        });
    });

    describe("#1398", function() {
        it("Call order takes into account both calledBefore and callCount", function() {
            var s1 = sinon.spy();
            var s2 = sinon.spy();

            s1();
            s2();
            s1();

            assert.exception(function() {
                sinon.assert.callOrder(s2, s1, s2);
            });
        });
    });

    describe("#1474 - promise library should be propagated through fakes and behaviors", function() {
        var stub;

        function makeAssertions(fake, expected) {
            assert.isFunction(fake.then);
            assert.isFunction(fake.tap);

            assert.equals(fake.tap(), expected);
        }

        before(function() {
            if (!global.Promise) {
                this.skip();
            }
        });

        beforeEach(function() {
            var promiseLib = {
                resolve: function(value) {
                    var promise = Promise.resolve(value);
                    promise.tap = function() {
                        return "tap " + value;
                    };

                    return promise;
                }
            };

            stub = sinon.stub().usingPromise(promiseLib);

            stub.resolves("resolved");
        });

        it("stub.onCall", function() {
            stub.onSecondCall().resolves("resolved again");

            makeAssertions(stub(), "tap resolved");
            makeAssertions(stub(), "tap resolved again");
        });

        it("stub.withArgs", function() {
            stub.withArgs(42).resolves("resolved again");
            stub.withArgs(true).resolves("okay");

            makeAssertions(stub(), "tap resolved");
            makeAssertions(stub(42), "tap resolved again");
            makeAssertions(stub(true), "tap okay");
        });
    });

    describe("#1456", function() {
        var sandbox;

        function throwsOnUnconfigurableProperty() {
            /* eslint-disable no-restricted-syntax */
            try {
                var preDescriptor = Object.getOwnPropertyDescriptor(window, "innerHeight"); //backup val
                Object.defineProperty(window, "innerHeight", { value: 10, configureable: true, writeable: true });
                Object.defineProperty(window, "innerHeight", preDescriptor); //restore
                return false;
            } catch (err) {
                return true;
            }
            /* eslint-enable no-restricted-syntax */
        }

        beforeEach(function() {
            if (typeof window === "undefined" || throwsOnUnconfigurableProperty()) {
                this.skip();
            }

            sandbox = sinon.createSandbox();
        });

        afterEach(function() {
            sandbox.restore();
        });

        it("stub window innerHeight", function() {
            sandbox.stub(window, "innerHeight").value(111);

            assert.equals(window.innerHeight, 111);
        });
    });

    describe("#1487 - withArgs() returnValue", function() {
        beforeEach(function() {
            this.stub = createStub().throws("Nothing set");
            this.stub.withArgs("arg").returns("return value");
            this.stub("arg");
        });

        it("sets correct firstCall.returnValue", function() {
            assert.equals(this.stub.withArgs("arg").firstCall.returnValue, "return value");
        });

        it("sets correct lastCall.returnValue", function() {
            assert.equals(this.stub.withArgs("arg").lastCall.returnValue, "return value");
        });
    });

    describe("#1512 - sandbox.stub(obj,protoMethod)", function() {
        var sandbox;

        beforeEach(function() {
            sandbox = sinon.createSandbox();
        });

        afterEach(function() {
            sandbox.restore();
        });

        it("can stub methods on the prototype", function() {
            var proto = {
                someFunction: function() {
                    return;
                }
            };
            var instance = Object.create(proto);

            var stub = sandbox.stub(instance, "someFunction");
            instance.someFunction();
            assert(stub.called);
        });
    });

    describe("#1521 - stubbing Array.prototype.filter", function() {
        var orgFilter;

        before(function() {
            orgFilter = Array.prototype.filter;
        });

        afterEach(function() {
            /* eslint-disable no-extend-native */
            Array.prototype.filter = orgFilter;
        });

        it("should be possible stub filter", function() {
            var stub = sinon.stub(Array.prototype, "filter");
            [1, 2, 3].filter(function() {
                return false;
            });
            assert(stub.calledOnce);
        });
    });

    describe("#1531 - some copied functions on root sinon module throw", function() {
        it("should create a fake server without throwing", function() {
            refute.exception(function() {
                sinon.createFakeServer();
            });
        });

        it("should create a fake server with clock without throwing", function() {
            refute.exception(function() {
                sinon.createFakeServerWithClock();
            });
        });
    });

    describe("#1442 - callThrough with a mock expectation", function() {
        it("should call original method", function() {
            var foo = {
                bar: function() {
                    return;
                }
            };

            var mock = this.sandbox.mock(foo);
            mock.expects("bar").callThrough();

            foo.bar();

            mock.verify();
        });
    });

    describe("#1648 - resetHistory ", function() {
        it("should reset property spies", function() {
            var obj = {
                func: function() {
                    return;
                },
                get prop() {
                    return 1;
                }
            };

            var sandbox = sinon.createSandbox();
            var spyFunc = sandbox.spy(obj, "func");
            var spyProp = sandbox.spy(obj, "prop", ["get"]);

            refute.isTrue(spyFunc.called);
            refute.isTrue(spyProp.get.called);

            obj.func();
            //eslint-disable-next-line no-unused-expressions
            obj.prop;

            assert.isTrue(spyFunc.called);
            assert.isTrue(spyProp.get.called);

            sandbox.resetHistory();

            refute.isTrue(spyFunc.called);
            refute.isTrue(spyProp.get.called);
        });
    });

    // this error was caused by overwriting methods with imported ones don't use the collection
    // and thus were not restorable
    describe("#1775 - sinon.restore", function() {
        it("should restore all stubs", function() {
            var myApi = {
                someMethod: function someMethod() {
                    // eslint-disable-next-line no-console
                    console.log("test method!");
                }
            };

            sinon.stub(myApi, "someMethod");
            sinon.restore();
            sinon.stub(myApi, "someMethod");
            // TypeError: Attempted to wrap someMethod which is already wrapped
        });

        it("should restore all spies", function() {
            var myApi = {
                someMethod: function someMethod() {
                    // eslint-disable-next-line no-console
                    console.log("test method!");
                }
            };

            sinon.spy(myApi, "someMethod");
            sinon.restore();
            sinon.spy(myApi, "someMethod");
            // TypeError: Attempted to wrap someMethod which is already wrapped
        });

        it("should restore all mocks", function() {
            var myApi = {
                someMethod: function someMethod() {
                    // eslint-disable-next-line no-console
                    console.log("test method!");
                }
            };

            sinon.mock(myApi);
            sinon.restore();
            sinon.mock(myApi);
            // TypeError: Attempted to wrap someMethod which is already wrapped
        });
    });

    describe("#1801 - sinon.restore spied fakeTimers", function() {
        it("should restore spied fake timers", function() {
            var originalSetTimeout = setTimeout;

            sinon.useFakeTimers();
            sinon.spy(global, "setTimeout");

            sinon.restore();

            assert.same(originalSetTimeout, global.setTimeout, "fakeTimers restored");
        });
    });

    describe("#1840 - sinon.restore useFakeXMLHttpRequest", function() {
        it("should restore XMLHttpRequest and ActiveXObject", function() {
            sinon.useFakeXMLHttpRequest();
            sinon.restore();

            assert.same(global.XMLHttpRequest, globalXHR);
            assert.same(global.ActiveXObject, globalAXO);
        });
    });

    describe("#1709 - deepEqual fails on cyclic references", function() {
        it("should not blow up", function() {
            var spy = sinon.spy();

            var firstObj = {};
            firstObj.aKeyName = firstObj;

            var secondObj = {};
            secondObj.aKeyName = secondObj;

            spy(firstObj);

            sinon.assert.calledWith(spy, secondObj);
        });
    });

    describe("#1796 - cannot stub Array.prototype.sort", function() {
        it("it should not fail with RangeError", function() {
            var stub = sinon.stub(Array.prototype, "sort");

            refute.exception(function() {
                [1, 2, 3].sort();
            });

            stub.restore();
        });
    });

    describe("#1900 - calledWith returns false positive", function() {
        it("should return false when call args don't match", function() {
            var spy = sinon.spy();
            var dateOne = new Date("2018-07-01");
            var dateTwo = new Date("2018-07-31");

            spy(dateOne);

            var calledWith = spy.calledWith(dateTwo);
            assert.same(calledWith, false);
        });
    });

    describe("#1882", function() {
        it("should use constructor name when checking deepEquality", function() {
            function ClassWithoutProps() {
                return;
            }
            function AnotherClassWithoutProps() {
                return;
            }
            ClassWithoutProps.prototype.constructor = ClassWithoutProps;
            AnotherClassWithoutProps.prototype.constructor = AnotherClassWithoutProps;
            var arg1 = new ClassWithoutProps(); //arg1.constructor.name === ClassWithoutProps
            var arg2 = new AnotherClassWithoutProps(); //arg2.constructor.name === Object
            var stub = sinon.stub();
            stub.withArgs(arg1).returns(5);
            var result = stub(arg2);
            assert.same(result, undefined); //[ERR_ASSERTION]: 5 === undefined
        });
    });

    describe("#1887", function() {
        it("should not break stub behavior using multiple `match.any`", function() {
            var stub = sinon.stub();

            stub.withArgs(sinon.match.any, sinon.match.any, sinon.match("a")).returns("a");
            stub.withArgs(sinon.match.any, sinon.match.any, sinon.match("b")).returns("b");

            assert.equals(stub({}, [], "a"), "a");
            assert.equals(stub({}, [], "b"), "b");
        });
    });

    describe("#1986", function() {
        it("should not set `lastArg` to undefined when last argument is `false`", function() {
            var fake = sinon.fake();

            fake(99, false);

            assert.equals(fake.lastArg, false);
        });
    });

    describe("#1964", function() {
        it("should allow callThrough on a withArgs fake", function() {
            var calledThrough = false;
            var obj = {
                method: function() {
                    calledThrough = true;
                }
            };

            var baseStub = sinon.stub(obj, "method");
            baseStub.throws("Should always hit the withArgs fake");
            var argsStub = baseStub.withArgs("foo").callThrough();

            obj.method("foo");

            sinon.assert.calledOnce(argsStub);
            assert.isTrue(calledThrough);
        });
    });

    describe("#2016", function() {
        function Foo() {
            return;
        }
        Foo.prototype.testMethod = function() {
            return;
        };

        var sandbox;
        beforeEach(function() {
            sandbox = sinon.createStubInstance(Foo);
        });

        afterEach(function() {
            sinon.restore();
        });

        describe("called on individual stub method", function() {
            it("should clear 'called' status on stub", function() {
                sandbox.testMethod();
                assert.isTrue(sandbox.testMethod.called);

                sandbox.testMethod.resetHistory();
                assert.isFalse(sandbox.testMethod.called);
            });
        });

        describe("called on module", function() {
            it("should clear 'called' status on all stubs", function() {
                sandbox.testMethod();
                assert.isTrue(sandbox.testMethod.called);

                sinon.resetHistory();
                assert.isFalse(sandbox.testMethod.called);
            });
        });
    });
});


text:
You use the Specter Start to launch your app.

To do this you simply type:

```$ specter start app```
(do not type the dollar sign.)

Specter also has a unique system to launch php apps.

```$ specter start server```,

It will prompt you with: ```What port is your server on?```

Here you type in the localhost port (what is after : in localhost url)

From here it will start your app on you localhost apache server.

redpajama_set_name: RedPajamaGithub


text:
FALK
====

FALK is a Framework for Acoustic Logging of Keystrokes and originated from a course project.

It will soon* be made available after some much needed code cleanup

\* for some definitions of 'soon'


text:
package io.volkan;

import io.volkan.entities.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.*;

import javax.annotation.Resource;
import javax.sql.DataSource;

// ACID
// Atomic, Consistent, Isolated, Durable
// All or nothing.
//         DB Integrity constraints never violated.
//                     How transactions see work donw by others.
//                               Committed changes that are permanent.

// @Transactional: Manages a transaction manager
// Both the entry and also the exit of a message queue is transactional.

@Configuration
// @Import(InfrastructureConfig.class)
@ComponentScan(basePackages = "io.volkan") // <- This is only done at startup time,
                                           //    but you'd want to reduce its scope as much as you can.
@EnableAspectJAutoProxy
public class AppConfig {

    @Autowired // <- go find a bean of type DataSource exists and assign it to this.
    private DataSource dataSource; // Spring does not care where it came from and says "go find it".

    // @Autowired means "autowire by type" first.
    // This works, if there is exactly one bean of that type (class) available.

    // With this Java-based configuration approach, you can keep the configuration
    // of your beans centralized. Plus, you are able to use the compiler to make sure
    // that you are doing the things appropriately. And finally you have the entire
    // power of the language available to you should you want to configure the beans
    // in a more convoluted way.

    // src/main/resources -> non-java-related stuff.

    // Around aspects are pretty useful.
    // Leave aspects for the infrastructure; don't get too clever!

    @Autowired @Qualifier("redSox")
    private Team home;

    @Resource // <- Autowire by name.
    private Team cubs;

    // @ComponentScan
    // @Autowire
    // @Qualifier
    // @Resource -> Allowed us to remove beans entirely from the configuration file,
    //              to pick them up later during the initialization process.
    //
    // Also @Autowired allows us to pick the bean from any resource we want,
    // including XML configurations.

    // What often happens is, you make a package for each type you want to be
    // found on a component scan.

    //@Bean(initMethod = "startGame", destroyMethod = "endGame")
    @Bean
    public Game game() {
        // Spring will find a bean that matches the type `DataSource` and populate the parameter
        // automatically.
        // @Scope("prototype") // <- every time I call getBean create a new one.

    // public Game game(DataSource dataSource) {
    //                         // ^ This will be picked up from the other configuration file.

        // Spring assumes that all of these classes are in fact singletons and we
        // are going to only get one.
        // So if the bean has already been instantiated, Spring will provide that
        // to you; and if it has not been instantiated, it will instantiate and
        // will put it into the Spring context.
        // BaseballGame baseballGame = new BaseballGame(redSox(), cubs());

        BaseballGame baseballGame = new BaseballGame(home, cubs);

        baseballGame.setDataSource(dataSource);

        return baseballGame;
    }

// Abstract class :: cannot be instantiated.

// Spring is a giant-ass bean factory on steroids.

// Default scope is singleton, others are request, session (if you are using SpringMVC).
// Plus you can define your custom scope for advanced use cases.

//    @Bean
//    public Team redSox() {
//        return new RedSox();
//    }

//    Spring overrides this method to return a singleton (in default config).
//    @Bean
//    public Team cubs() {
//        return new Cubs();
//    }
}


text:
[jLim fx Plugin](http://www.freelancephp.net/jlim-fx-plugin-animation/)
=======================================================================

jLim plugin for the small [$fx animation library](http://www.leigeber.com/) made by Sergii Iavorskyi.

How To Use?
-----------

	// when DOM is ready
	jLim(function ($) {

		var move = {type: 'left', from:85, to:1000, step:4, delay:20},
			disappear = {type: 'opacity', from:100, to:0, step: -1, delay:50};

		$('#demoButton').click(function () {
			$('#demoDiv')
				.fxReset()
				.fxAdd(disappear)
				.fxAdd(move)
				.fxRun();
		});

	});

API
---

* `.fadeIn( [ duration ], [ callback ] )`
* `.fadeOut( [ duration ], [ callback ] )`
* `.fxAdd( params )`
* `.fxAddSet()`
* `.fxHold( delay )`
* `.fxPause( status, [setNum] )`
* `.fxStop( [setNum] )`
* `.fxReset()`
* `.fxRun( [ finalCallback ], [ loops ], [ loopCallback ] )`

Note: These jLim fx functions will return the jLim object for chaining (instead of the fx object).

Browser Support
---------------

Tested on IE6+, FF, Opera, Chrome and Safari (for Windows).

License
-------

Plugin was released under MIT license and the $fx library was released under [MIT](http://fx.inetcat.com/license/MIT-LICENSE.txt) and [GPL](http://fx.inetcat.com/license/GPL-LICENSE.txt) license.

Questions?
----------

If you have any questions, please ask them by using [this contactform](http://www.freelancephp.net/contact).


text:
--
select r.first_name, r.last_name, r.email, r.residing_country,
	r.dance_role, pt.type as pass_type, pt.name as pass_name,
	r.workshop_partner_name, r.workshop_partner_email,
	case when r.include_lunch=true then 'yes' else 'no' end as include_lunch,
	crew_remarks,
	(select string_agg(ct.name, ',') as competitions
		from registration_registration_competitions c
			join registration_competitiontype ct on c.competitiontype_id = ct.id
		where c.registration_id = r.id
	), r.strictly_partner,
	(select string_agg(vt.name, ',') as volunteering_for
		from registration_registration_volunteering_for v
			join registration_volunteertype vt on v.volunteertype_id = vt.id
		where v.registration_id = r.id
	)
	from registration_registration r
		left join registration_passtype pt on r.pass_type_id = pt.id
	where exists (
			select 1
			from registration_molliepayment p
			where r.id = p.registration_id and p.mollie_status = 'paid')
union
select o.first_name, o.last_name, o.email, '' as residing_country,
	case when i.product_name like '%follower%' then 'follower' else 'leader' end,
	'party' as pass_type, 'Party' as pass_name,
	'' as workshop_partner_name, '' as workshop_partner_email, 'no' as include_lunch,
	'(Purchased from SF shop)' as crew_remarks, '' as competitions, '' as strictly_partner,
	'' as volunteering_for
	from minishop_order o
		join minishop_orderitem i on o.id = i.order_id
	where o.mollie_payment_status = 'paid'
	order by last_name
	;


text:
package com.amazonaws.services.storagegateway.model;

import java.io.Serializable;
import javax.annotation.Generated;

import com.amazonaws.AmazonWebServiceRequest;

/**
 *

 * DeleteFileShareInput
 *

 *
 * @see AWS API
 *      Documentation
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class DeleteFileShareRequest extends com.amazonaws.AmazonWebServiceRequest implements Serializable, Cloneable {

    /**
     *

     * The Amazon Resource Name (ARN) of the file share to be deleted.
     *

     */
    private String fileShareARN;
    /**
     *

     * If this value is set to true, the operation deletes a file share immediately and aborts all data
     * uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded to Amazon Web
     * Services. This process aborts the data upload process, and the file share enters the FORCE_DELETING
     * status.
     *

     *

     * Valid Values: true | false
     *

     */
    private Boolean forceDelete;

    /**
     *

     * The Amazon Resource Name (ARN) of the file share to be deleted.
     *

     *
     * @param fileShareARN
     *        The Amazon Resource Name (ARN) of the file share to be deleted.
     */

    public void setFileShareARN(String fileShareARN) {
        this.fileShareARN = fileShareARN;
    }

    /**
     *

     * The Amazon Resource Name (ARN) of the file share to be deleted.
     *

     *
     * @return The Amazon Resource Name (ARN) of the file share to be deleted.
     */

    public String getFileShareARN() {
        return this.fileShareARN;
    }

    /**
     *

     * The Amazon Resource Name (ARN) of the file share to be deleted.
     *

     *
     * @param fileShareARN
     *        The Amazon Resource Name (ARN) of the file share to be deleted.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public DeleteFileShareRequest withFileShareARN(String fileShareARN) {
        setFileShareARN(fileShareARN);
        return this;
    }

    /**
     *

     * If this value is set to true, the operation deletes a file share immediately and aborts all data
     * uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded to Amazon Web
     * Services. This process aborts the data upload process, and the file share enters the FORCE_DELETING
     * status.
     *

     *

     * Valid Values: true | false
     *

     *
     * @param forceDelete
     *        If this value is set to true, the operation deletes a file share immediately and aborts all
     *        data uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded
     *        to Amazon Web Services. This process aborts the data upload process, and the file share enters the
     *        FORCE_DELETING status.

     *

     *        Valid Values: true | false
     */

    public void setForceDelete(Boolean forceDelete) {
        this.forceDelete = forceDelete;
    }

    /**
     *

     * If this value is set to true, the operation deletes a file share immediately and aborts all data
     * uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded to Amazon Web
     * Services. This process aborts the data upload process, and the file share enters the FORCE_DELETING
     * status.
     *

     *

     * Valid Values: true | false
     *

     *
     * @return If this value is set to true, the operation deletes a file share immediately and aborts all
     *         data uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded
     *         to Amazon Web Services. This process aborts the data upload process, and the file share enters the
     *         FORCE_DELETING status.

     *

     *         Valid Values: true | false
     */

    public Boolean getForceDelete() {
        return this.forceDelete;
    }

    /**
     *

     * If this value is set to true, the operation deletes a file share immediately and aborts all data
     * uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded to Amazon Web
     * Services. This process aborts the data upload process, and the file share enters the FORCE_DELETING
     * status.
     *

     *

     * Valid Values: true | false
     *

     *
     * @param forceDelete
     *        If this value is set to true, the operation deletes a file share immediately and aborts all
     *        data uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded
     *        to Amazon Web Services. This process aborts the data upload process, and the file share enters the
     *        FORCE_DELETING status.

     *

     *        Valid Values: true | false
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public DeleteFileShareRequest withForceDelete(Boolean forceDelete) {
        setForceDelete(forceDelete);
        return this;
    }

    /**
     *

     * If this value is set to true, the operation deletes a file share immediately and aborts all data
     * uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded to Amazon Web
     * Services. This process aborts the data upload process, and the file share enters the FORCE_DELETING
     * status.
     *

     *

     * Valid Values: true | false
     *

     *
     * @return If this value is set to true, the operation deletes a file share immediately and aborts all
     *         data uploads to Amazon Web Services. Otherwise, the file share is not deleted until all data is uploaded
     *         to Amazon Web Services. This process aborts the data upload process, and the file share enters the
     *         FORCE_DELETING status.

     *

     *         Valid Values: true | false
     */

    public Boolean isForceDelete() {
        return this.forceDelete;
    }

    /**
     * Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
     * redacted from this string using a placeholder value.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getFileShareARN() != null)
            sb.append("FileShareARN: ").append(getFileShareARN()).append(",");
        if (getForceDelete() != null)
            sb.append("ForceDelete: ").append(getForceDelete());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof DeleteFileShareRequest == false)
            return false;
        DeleteFileShareRequest other = (DeleteFileShareRequest) obj;
        if (other.getFileShareARN() == null ^ this.getFileShareARN() == null)
            return false;
        if (other.getFileShareARN() != null && other.getFileShareARN().equals(this.getFileShareARN()) == false)
            return false;
        if (other.getForceDelete() == null ^ this.getForceDelete() == null)
            return false;
        if (other.getForceDelete() != null && other.getForceDelete().equals(this.getForceDelete()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getFileShareARN() == null) ? 0 : getFileShareARN().hashCode());
        hashCode = prime * hashCode + ((getForceDelete() == null) ? 0 : getForceDelete().hashCode());
        return hashCode;
    }

    @Override
    public DeleteFileShareRequest clone() {
        return (DeleteFileShareRequest) super.clone();
    }

}


text:
**bold**
*italic*
[link](http://www.google.com)
` code block `


text:
import { ObjectID } from 'mongodb';

const getString = value => (value || '').toString();

const getDateIfValid = value => {
	const date = Date.parse(value);
	return isNaN(date) ? null : new Date(date);
};

const getArrayIfValid = value => {
	return Array.isArray(value) ? value : null;
};

const getArrayOfObjectID = value => {
	if (Array.isArray(value) && value.length > 0) {
		return value.map(id => getObjectIDIfValid(id)).filter(id => !!id);
	} else {
		return [];
	}
};

const isNumber = value => !isNaN(parseFloat(value)) && isFinite(value);

const getNumberIfValid = value => (isNumber(value) ? parseFloat(value) : null);

const getNumberIfPositive = value => {
	const n = getNumberIfValid(value);
	return n && n >= 0 ? n : null;
};

const getBooleanIfValid = (value, defaultValue = null) => {
	if (value === 'true' || value === 'false') {
		return value === 'true';
	} else {
		return typeof value === 'boolean' ? value : defaultValue;
	}
};

const getObjectIDIfValid = value => {
	return ObjectID.isValid(value) ? new ObjectID(value) : null;
};

const getBrowser = browser => {
	return browser
		? {
				ip: getString(browser.ip),
				user_agent: getString(browser.user_agent)
		  }
		: {
				ip: '',
				user_agent: ''
		  };
};

const getCustomerAddress = address => {
	let coordinates = {
		latitude: '',
		longitude: ''
	};

	if (address && address.coordinates) {
		coordinates.latitude = address.coordinates.latitude;
		coordinates.longitude = address.coordinates.longitude;
	}

	return address
		? {
				id: new ObjectID(),
				address1: getString(address.address1),
				address2: getString(address.address2),
				city: getString(address.city),
				country: getString(address.country).toUpperCase(),
				state: getString(address.state),
				phone: getString(address.phone),
				postal_code: getString(address.postal_code),
				full_name: getString(address.full_name),
				company: getString(address.company),
				tax_number: getString(address.tax_number),
				coordinates: coordinates,
				details: address.details,
				default_billing: false,
				default_shipping: false
		  }
		: {};
};

const getOrderAddress = address => {
	let coordinates = {
		latitude: '',
		longitude: ''
	};

	if (address && address.coordinates) {
		coordinates.latitude = address.coordinates.latitude;
		coordinates.longitude = address.coordinates.longitude;
	}

	const emptyAddress = {
		address1: '',
		address2: '',
		city: '',
		country: '',
		state: '',
		phone: '',
		postal_code: '',
		full_name: '',
		company: '',
		tax_number: '',
		coordinates: coordinates,
		details: null
	};

	return address
		? Object.assign(
				{},
				{
					address1: getString(address.address1),
					address2: getString(address.address2),
					city: getString(address.city),
					country: getString(address.country).toUpperCase(),
					state: getString(address.state),
					phone: getString(address.phone),
					postal_code: getString(address.postal_code),
					full_name: getString(address.full_name),
					company: getString(address.company),
					tax_number: getString(address.tax_number),
					coordinates: coordinates,
					details: address.details
				},
				address
		  )
		: emptyAddress;
};

export default {
	getString: getString,
	getObjectIDIfValid: getObjectIDIfValid,
	getDateIfValid: getDateIfValid,
	getArrayIfValid: getArrayIfValid,
	getArrayOfObjectID: getArrayOfObjectID,
	getNumberIfValid: getNumberIfValid,
	getNumberIfPositive: getNumberIfPositive,
	getBooleanIfValid: getBooleanIfValid,
	getBrowser: getBrowser,
	getCustomerAddress: getCustomerAddress,
	getOrderAddress: getOrderAddress
};


text:
<?php

namespace Isolate\LazyObjects\Proxy\Adapter\OcramiusProxyManager\MethodGenerator;

use ProxyManager\Generator\MethodGenerator;
use ProxyManager\Generator\ParameterGenerator;
use ReflectionClass;
use ReflectionProperty;
use Zend\Code\Generator\PropertyGenerator;

class Constructor extends MethodGenerator
{
    /**
     * Constructor
     */
    public function __construct(
        ReflectionClass $originalClass,
        PropertyGenerator $wrappedObjectProperty,
        PropertyGenerator $lazyPropertiesProperty,
        PropertyGenerator $methodReplacementsProperty,
        PropertyGenerator $initializerProperty
    ) {
        parent::__construct('__construct');

        $lazyPropertiesArg = new ParameterGenerator('lazyProperties');
        $lazyPropertiesArg->setDefaultValue([]);
        $lazyPropertiesArg->setType('array');

        $methodReplacementsArg = new ParameterGenerator('methodReplacements');
        $methodReplacementsArg->setDefaultValue([]);
        $methodReplacementsArg->setType('array');

        $this->setParameter(new ParameterGenerator('wrappedObject'));
        $this->setParameter($lazyPropertiesArg);
        $this->setParameter($methodReplacementsArg);

        $this->setBody(
              '$this->' . $wrappedObjectProperty->getName() . " = \$wrappedObject;\n"
            . '$this->' . $lazyPropertiesProperty->getName() . " = \$lazyProperties;\n"
            . '$this->' . $methodReplacementsProperty->getName() . " = \$methodReplacements;\n"
            . '$this->' . $initializerProperty->getName() . " = new \\Isolate\\LazyObjects\\Object\\Property\\Initializer();\n"
            . '$this->' . $initializerProperty->getName() . "->initialize(\$this->" . $lazyPropertiesProperty->getName() . ", \"__construct\", \$this->" . $wrappedObjectProperty->getName() . ");\n"
        );
    }
}


text:
Follow this steps to integrate OSVR into your UE4 project:
+ install OSVR on your system
+ be sure that your project have at least one C++ file
+ close UE4Editor
+ copy the "OSVR/" plugin directory into "<YourProject>/Plugins/"
+ copy all content of "<YourProject>\Plugins\OSVR\ThirdParty\OSVR\bin\" into "<YourProject>\Binaries\"
+ open you project and let UBT to recompile the OSVR plugin
+ under "Window -> Plugins" ensure that OSVR is the only plugin of type "Head Mounted Display" enabled (e.g., be sure to have "Oculus Rift Plugin" and "SteamVR Plugin" both disabled)

##Packaging
After having packaged your project:
+ copy all content of "<YourProject>\Plugins\OSVR\ThirdParty\OSVR\bin\" into "<OutputDir>\WindowsNoEditor\<YourProject>\Binaries\"

##Blueprint API
APIs identify OSVR devices/resources using the same OSVR resource path notation.
Following UE4 input management, as general rule:
+ state of continuous valued resources ("axis" inputs in UE4) is queried by polling, using functions defined in the OSVR Blueprint Function Library.
+ state of discrete valued resources ("action" inputs in UE4) is reported by events. As UE4 currently does not support the definition of global events, OSVR events are wrapped in OSVRInputComponent and OSVRActor classes.

##OSVRActor
Predefined Actor class containing an OSVRInputComponent.
It can be used as a base class for custom Actors or can ben placed into a level to manage OSVR action events directly from the "Level Blueprint".

##OSVRInputComponent
Component exposing OSVR action events. You can use it to bind custom actions to OSVR action events like buttons press, etc.
**void OnPositionChanged (FName name, FVector position);**
Fired when the position of an OSVR resource changes.

Outputs:
+ name: **OSVR resource path;**
+ position: **the new position.**
void **OnOrientationChanged** (FName name, FRotator orientation);
Fired when the orientation of an OSVR resource changes.
Outputs:
+ name: **OSVR resource path;**
+ position: **the new orientation.**
void **OnButtonStateChanged** (FName name, EButtonState::Type state);
Fired when the state of a button of an OSVR resource changes.

Outputs:
+ name: **OSVR resource path;**
+ state: **the new button state** (PRESSED, NOT_PRESSED).

void **OnAnalogValueChanged** (FName name, float value);
Fired when the value of a single-valued analog resource changes (e.g. a gamepad trigger analog control).

Outputs:
+ name: OSVR resource path;
+ value: the new value, in [0, 1].

**Blueprint function library
static FVector **GetInterfacePosition**(FName Name);
Return the current position of an OSVR resource.

Inputs:
+ name: **OSVR resource path.**
static FRotator **GetInterfaceRotation**(FName Name);
Return the current orientation of an OSVR resource.

Inputs:
+ name: OSVR resource path.
static EButtonState::Type **GetInterfaceButtonState**(FName Name);
Return the current state of an OSVR button.

Inputs:
+ name: OSVR resource path.
static float **GetInterfaceAnalogValue**(FName Name);
Return the current value of a single-valued OSVR analog resource (e.g. a gamepad trigger analog control).

Inputs:
+ name: OSVR resource path.
static void **SetCurrentHmdOrientationAndPositionAsBase();**
Set the current position and orientation of OSVR HMD device as "rest" position.


text:
/**
 * Check the URL of the given browser window
 * @param  {String}   falseCase   Whether to check if the URL matches the
 *                                expected value or not
 * @param  {String}   expectedUrl The expected URL to check against
 * @param  {Function} done        Function to execute when finished
 */
module.exports = (falseCase, expectedUrl, done) => {
    /**
     * The current browser window's URL
     * @type {String}
     */
    const currentUrl = browser.url().value;
    const urlEsperada = browser.options.baseUrl + expectedUrl;

    if (falseCase) {
        currentUrl.should.not
            .equal(urlEsperada, `expected url not to be "${currentUrl}`);
    } else {
        currentUrl.should
            .equal(
                urlEsperada,
                `expected url to be "${urlEsperada}" but found
                "${currentUrl}"`
            );
    }

    done();
};


text:
package com.hazelcast.examples.csv;

import org.supercsv.cellprocessor.ParseInt;
import org.supercsv.cellprocessor.constraint.NotNull;
import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.io.CsvBeanReader;
import org.supercsv.io.ICsvBeanReader;
import org.supercsv.prefs.CsvPreference;

import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public abstract class AbstractDataReader<T>
        implements DataReader<T> {

    protected static final CellProcessor INT = new ParseInt();
    protected static final CellProcessor NOT_NULL = new NotNull();

    private final CellProcessor[] cellProcessors;
    private final Class<T> type;

    public AbstractDataReader(CellProcessor[] cellProcessors, Class<T> type) {
        this.cellProcessors = cellProcessors;
        this.type = type;
    }

    @Override
    public List<T> read(InputStream is)
            throws Exception {

        List<T> elements = new ArrayList<>();
        try (ICsvBeanReader reader = new CsvBeanReader(new InputStreamReader(is), CsvPreference.EXCEL_PREFERENCE)) {
            String[] headers = mapHeaderNames(reader.getHeader(true));

            T element;
            while ((element = reader.read(type, headers, cellProcessors)) != null) {
                elements.add(element);
            }
        }
        return elements;
    }

    private String[] mapHeaderNames(String[] headers) {
        for (int i = 0; i < headers.length; i++) {
            headers[i] = mapHeaderName(headers[i]);
        }
        return headers;
    }

    private String mapHeaderName(String header) {
        StringBuilder sb = new StringBuilder(header.length());

        char[] chars = header.toCharArray();

        boolean nextUpperCase = false;
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (Character.isWhitespace(c) || c == '_') {
                nextUpperCase = true;
                continue;
            } else {
                sb.append(nextUpperCase ? Character.toUpperCase(c) : c);
            }
            nextUpperCase = false;
        }

        return sb.toString();
    }
}