text:
package yarpctest

import (
	"context"
	"errors"
	"fmt"
	"io/ioutil"

	"go.uber.org/yarpc/api/peer"
	"go.uber.org/yarpc/api/transport"
	"go.uber.org/yarpc/api/transport/transporttest"
	"go.uber.org/yarpc/pkg/lifecycle"
)

var (
	_ transport.Namer          = (*FakeOutbound)(nil)
	_ transport.UnaryOutbound  = (*FakeOutbound)(nil)
	_ transport.OnewayOutbound = (*FakeOutbound)(nil)
	_ transport.StreamOutbound = (*FakeOutbound)(nil)
)

// FakeOutboundOption is an option for FakeTransport.NewOutbound.
type FakeOutboundOption func(*FakeOutbound)

// NopOutboundOption returns an option to set the "nopOption" for a
// FakeTransport.NewOutbound.
// The nopOption has no effect exists only to verify that the option was
// passed, via `FakeOutbound.NopOption()`.
func NopOutboundOption(nopOption string) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.nopOption = nopOption
	}
}

// OutboundName sets the name of the "fake" outbound.
func OutboundName(name string) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.name = name
	}
}

// OutboundCallable is a function that will be called for for an outbound's
// `Call` method.
type OutboundCallable func(ctx context.Context, req *transport.Request) (*transport.Response, error)

// OutboundOnewayCallable is a function that will be called for for an outbound's
// `Call` method.
type OutboundOnewayCallable func(context.Context, *transport.Request) (transport.Ack, error)

// OutboundStreamCallable is a function that will be called for for an outbound's
// `Call` method.
type OutboundStreamCallable func(context.Context, *transport.StreamRequest) (*transport.ClientStream, error)

// OutboundRouter returns an option to set the router for outbound requests.
// This connects the outbound to the inbound side of a handler for testing
// purposes.
func OutboundRouter(router transport.Router) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.router = router
	}
}

// OutboundCallOverride returns an option to set the "callOverride" for a
// FakeTransport.NewOutbound.
// This can be used to set the functionality for the FakeOutbound's `Call`
// function.
func OutboundCallOverride(callable OutboundCallable) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.callOverride = callable
	}
}

// OutboundCallOnewayOverride returns an option to set the "callOverride" for a
// FakeTransport.NewOutbound.
//
// This can be used to set the functionality for the FakeOutbound's `CallOneway`
// function.
func OutboundCallOnewayOverride(callable OutboundOnewayCallable) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.callOnewayOverride = callable
	}
}

// OutboundCallStreamOverride returns an option to set the "callOverride" for a
// FakeTransport.NewOutbound.
//
// This can be used to set the functionality for the FakeOutbound's `CallStream`
// function.
func OutboundCallStreamOverride(callable OutboundStreamCallable) FakeOutboundOption {
	return func(o *FakeOutbound) {
		o.callStreamOverride = callable
	}
}

// NewOutbound returns a FakeOutbound with a given peer chooser and options.
func (t *FakeTransport) NewOutbound(c peer.Chooser, opts ...FakeOutboundOption) *FakeOutbound {
	o := &FakeOutbound{
		name:      "fake",
		once:      lifecycle.NewOnce(),
		transport: t,
		chooser:   c,
	}
	for _, opt := range opts {
		opt(o)
	}
	return o
}

// FakeOutbound is a unary outbound for the FakeTransport. It is fake.
type FakeOutbound struct {
	name      string
	once      *lifecycle.Once
	transport *FakeTransport
	chooser   peer.Chooser
	nopOption string
	router    transport.Router

	callOverride       OutboundCallable
	callOnewayOverride OutboundOnewayCallable
	callStreamOverride OutboundStreamCallable
}

// TransportName is "fake".
func (o *FakeOutbound) TransportName() string {
	return "fake"
}

// Chooser returns theis FakeOutbound's peer chooser.
func (o *FakeOutbound) Chooser() peer.Chooser {
	return o.chooser
}

// NopOption returns this FakeOutbound's nopOption. It is fake.
func (o *FakeOutbound) NopOption() string {
	return o.nopOption
}

// Start starts the fake outbound and its chooser.
func (o *FakeOutbound) Start() error {
	return o.once.Start(o.chooser.Start)
}

// Stop stops the fake outbound and its chooser.
func (o *FakeOutbound) Stop() error {
	return o.once.Stop(o.chooser.Stop)
}

// IsRunning returns whether the fake outbound is running.
func (o *FakeOutbound) IsRunning() bool {
	return o.once.IsRunning()
}

// Transports returns the FakeTransport that owns this outbound.
func (o *FakeOutbound) Transports() []transport.Transport {
	return []transport.Transport{o.transport}
}

// Call mimicks sending a oneway RPC.
//
// By default, this returns a error.
// The OutboundCallOverride option supplies an alternate implementation.
// Alternately, the OutboundRouter option may allow this function to route a
// unary request to a unary handler.
func (o *FakeOutbound) Call(ctx context.Context, req *transport.Request) (*transport.Response, error) {
	if o.callOverride != nil {
		return o.callOverride(ctx, req)
	}

	if o.router == nil {
		return nil, errors.New(`no outbound callable specified on the fake outbound`)
	}

	handler, err := o.router.Choose(ctx, req)
	if err != nil {
		return nil, err
	}

	unaryHandler := handler.Unary()
	if unaryHandler == nil {
		return nil, fmt.Errorf(`procedure %q for encoding %q does not handle unary requests`, req.Procedure, req.Encoding)
	}

	resWriter := &transporttest.FakeResponseWriter{}
	if err := unaryHandler.Handle(ctx, req, resWriter); err != nil {
		return nil, err
	}
	return &transport.Response{
		ApplicationError: resWriter.IsApplicationError,
		Headers:          resWriter.Headers,
		Body:             ioutil.NopCloser(&resWriter.Body),
	}, nil
}

// CallOneway mimicks sending a oneway RPC.
//
// By default, this returns an error.
// The OutboundCallOnewayOverride supplies an alternate implementation.
// Atlernately, the OutboundRouter options may route the request through to a
// oneway handler.
func (o *FakeOutbound) CallOneway(ctx context.Context, req *transport.Request) (transport.Ack, error) {
	if o.callOnewayOverride != nil {
		return o.callOnewayOverride(ctx, req)
	}

	if o.router == nil {
		return nil, errors.New(`fake outbound does not support call oneway`)
	}

	handler, err := o.router.Choose(ctx, req)
	if err != nil {
		return nil, err
	}

	onewayHandler := handler.Oneway()
	if onewayHandler == nil {
		return nil, fmt.Errorf(`procedure %q for encoding %q does not handle oneway requests`, req.Procedure, req.Encoding)
	}

	return nil, onewayHandler.HandleOneway(ctx, req)
}

// CallStream mimicks sending a streaming RPC.
//
// By default, this returns an error.
// The OutboundCallStreamOverride option provides a hook to change the behavior.
// Alternately, the OutboundRouter option may route the request through to a
// streaming handler.
func (o *FakeOutbound) CallStream(ctx context.Context, streamReq *transport.StreamRequest) (*transport.ClientStream, error) {
	if o.callStreamOverride != nil {
		return o.callStreamOverride(ctx, streamReq)
	}

	if o.router == nil {
		return nil, errors.New(`fake outbound does not support call stream`)
	}

	req := streamReq.Meta.ToRequest()
	handler, err := o.router.Choose(ctx, req)
	if err != nil {
		return nil, err
	}

	streamHandler := handler.Stream()
	if streamHandler == nil {
		return nil, fmt.Errorf(`procedure %q for encoding %q does not handle streaming requests`, req.Procedure, req.Encoding)
	}

	clientStream, serverStream, finish, err := transporttest.MessagePipe(ctx, streamReq)
	if err != nil {
		return nil, err
	}

	go func() {
		finish(streamHandler.HandleStream(serverStream))
	}()
	return clientStream, nil
}


text:
/* globals before, after, describe, it */
'use strict';

var assert = require('assert'),
    fs = require('fs'),
    path = require('path'),
    os = require('os');

var mocha = require('mocha'),
    Promise = require('promise'),
    uuid = require('uuid'),
    tempWrite = require('temp-write'),
    async = require('async');

var rimraf = Promise.denodeify(require('rimraf')),
    mkdirp = Promise.denodeify(require('mkdirp'));

var ROOT_TEST_FOLDER = 'node-fu-test';

var Storage = require('../../lib/traditional/storage');

function mktmp_file(size, name){
    return new Promise(function(resolve, reject){
        var content = '';

        for (var i = 0; i < size; i++){
            content = content + '0';
        }

        tempWrite(content, name, function(err, path){
            if (err) return reject(err);
            return resolve(path);
        });

    });
}

function mktmp_files(n, name, size){
    var size = size || 100;

    return new Promise(function(resolve, reject){

        function success(path){
            files.push(path);
        }

        function error(err){
            reject(err);
        }

        async.timesSeries(n, function(i, next){
            mktmp_file(size, name+'_'+i+'.dat').then(function(path){
                next(null, path);
            }, function(err){
                reject(err);
            })
        }, function(err, files){
            resolve(files);

        });

    });
}

function mktmp_dir(name){
    name = name || uuid.v4();

    return path.join(os.tmpdir(), name);

}

function MockChunk(uuid, name, index, path, totalChunks){

    var chunk_mock = { file: {} };
    chunk_mock.uuid = uuid;
    chunk_mock.name = name;
    chunk_mock.chunkIndex = index;
    chunk_mock.file.path = path;
    chunk_mock.totalChunks = totalChunks;

    return chunk_mock;

}

describe('traditional - storage', function(){

    var tmpRoot, chunksPath, uploadsPath, storage;

    beforeEach(function(){

        tmpRoot = mktmp_dir(ROOT_TEST_FOLDER);

        chunksPath = path.join(tmpRoot, 'chunks'),
        uploadsPath = path.join(tmpRoot, 'uploads');

        storage = new Storage(chunksPath, uploadsPath);

    });

    afterEach(function(){
        rimraf(tmpRoot);
    });

    function store_chunks(num_chunks, size){
        return new Promise(function(resolve, reject){

            mktmp_files(num_chunks, 'many-foochunks.dat', size).then(function(chunks){
                var totalChunks = chunks.length,
                    chunkUuid = uuid.v4();

                var i = 0,
                    newPath, chunk_mock;

                // note that this is an `eachSeries`
                async.eachSeries(chunks, function(chunk, done) {
                    chunk_mock = MockChunk(chunkUuid, 'foo.dat', i, chunk,
                                           totalChunks);
                    i++;
                    storage.store_chunk(chunk_mock).then(function(p){
                        newPath = p;
                        done();
                    }, done);
                }, function(err) {
                    if (err) {
                        return reject(err);
                    }
                    return resolve({
                        newPath: newPath,
                        chunk_mock: chunk_mock
                    });
                });
            });
        });
    }

    it('#store_file', function(done){

        var file_mock = { file: {} };

        file_mock.uuid = uuid.v4();
        file_mock.name = 'foo.dat';
        mktmp_file(100, 'foo.dat', 100).then(function(path){
            file_mock.file.path = path;
            return storage.store_file(file_mock).then(function(newPath){

                var stats = fs.statSync(newPath);
                if (stats.isFile()){
                    assert.ok(true);
                } else {
                    assert(false);
                }
                done();

            });

        });

    });

    it('#store_chunk', function(){
        //var chunks = mktmp_files(100, 'foo.dat', 100),
        mktmp_file(100, 'foo.dat').then(function(chunk){
            var  chunkUuid = uuid.v4();

            var chunk_mock = { file: {} };
            chunk_mock.uuid = chunkUuid;
            chunk_mock.name = 'foochunk.dat';
            chunk_mock.chunkIndex = 0;
            chunk_mock.file.path = chunk;
            chunk_mock.totalChunks = 1;

            storage.store_chunk(chunk_mock).then(function(newPath){
                assert(newPath.indexOf(chunksPath) !== -1, "Chunks not in to chunks path");
                var chunksPath = path.join(chunksPath, chunkUuid);
                var chunks = fs.readdirSync(chunksPath);

                assert(chunks.length === 1, "Missing chunks!");
                done();

            }, function(e) {
                assert(false, "Error storing chunk!");
                done(e);
            });

        });

    });

    describe("#store_chunks (many)", function(){
        this.timeout(10000);

        it("100x10B", function(done) {

            var numChunks = 100,
                chunkSize = 10;

            store_chunks(numChunks, chunkSize).then(function(data){
                var newPath = data.newPath,
                    chunk_mock = data.chunk_mock;

                var testChunksPath = path.join(chunksPath, chunk_mock.uuid),
                    chunkList = fs.readdirSync(testChunksPath);

                console.log('done?');
                done();
                assert(chunkList.length == numChunks, "Missing " + (totalChunks - chunkList.length) + " chunks!");
                //console.log('done?');
                //done();

            }, function(e) {
                assert(false, "Error storing chunk!");
                done(e);

            }).fail;
        });

        it("10000x1B", function(done) {

            var numChunks = 10000,
                chunkSize = 1;

            store_chunks(numChunks, chunkSize, function(data) {
                var newPath = data.newPath,
                    chunk_mock = data.chunk_mock;

                var testChunksPath = path.join(chunksPath, chunk_mock.uuid),
                    chunkList = fs.readdirSync(testChunksPath);

                console.log(chunkList.length);
                console.log(numChunks - 1);

                console.log("done?");
                done();
                assert(chunkList.length === numChunks - 1, "Missing " + (totalChunks - chunkList.length) + " chunks!");
                //console.log("done?");
                //done();

            }, function(e) {
                assert(false, "Error storing chunk!");
                done(e);

            });
        });

    });

    describe('#assemble_chunks', function(){

        it.skip("100x100B", function(done){
            store_chunks(100, 100, function(data){
                var newPath = data.newPath,
                    chunk_mock = data.chunk_mock;

                console.log(chunk_mock);
                storage.assemble_chunks(chunk_mock).then(function(){
                    var uploadedFile = path.join(uploadsPath, chunk_mock.uuid,
                                                    chunk_mock.name);
                    var uploadedFileStats = fs.statSync(testUploadsPath);

                    console.log(uploadedFileStats);

                    assert(uploadedFileStats.size === 100*100,
                           "Incorrect assembled chunk size");

                    done();

                }, function(e) {
                    assert(false, "Error assembling chunks");
                    done(e);

                });
            }, function(e) {
                assert(false, "Error storing chunks");
                done(e);

            });
        });

    });

    it.skip('#delete_file', function(){

    });

    it.skip('#verify_upload', function(){

    });

});

redpajama_set_name: RedPajamaGithub


text:
#ifndef _HPI6000_H_
#define _HPI6000_H_

#define HPI_NMIXER_CONTROLS 200

/*
 * Control caching is always supported in the HPI code.
 * The DSP should make sure that dwControlCacheSizeInBytes is initialized to 0
 * during boot to make it in-active.
 */
struct hpi_hif_6000 {
	u32 host_cmd;
	u32 dsp_ack;
	u32 address;
	u32 length;
	u32 message_buffer_address;
	u32 response_buffer_address;
	u32 dsp_number;
	u32 adapter_info;
	u32 control_cache_is_dirty;
	u32 control_cache_address;
	u32 control_cache_size_in_bytes;
	u32 control_cache_count;
};

#define HPI_HIF_PACK_ADAPTER_INFO(adapter, version_major, version_minor) \
		((adapter << 16) | (version_major << 8) | version_minor)
#define HPI_HIF_ADAPTER_INFO_EXTRACT_ADAPTER(adapterinfo) \
		((adapterinfo >> 16) & 0xffff)
#define HPI_HIF_ADAPTER_INFO_EXTRACT_HWVERSION_MAJOR(adapterinfo) \
		((adapterinfo >> 8) & 0xff)
#define HPI_HIF_ADAPTER_INFO_EXTRACT_HWVERSION_MINOR(adapterinfo) \
		(adapterinfo & 0xff)

/* Command/status exchanged between host and DSP */
#define HPI_HIF_IDLE            0
#define HPI_HIF_SEND_MSG        1
#define HPI_HIF_GET_RESP        2
#define HPI_HIF_DATA_MASK       0x10
#define HPI_HIF_SEND_DATA       0x13
#define HPI_HIF_GET_DATA        0x14
#define HPI_HIF_SEND_DONE       5
#define HPI_HIF_RESET           9

#endif				/* _HPI6000_H_ */


text:
StockPortfolio
==============

A simple implementation of a stocks' portfolio to demonstrate the use of mocking principles for unit-testing.
I have used [EasyMock](http://easymock.org) as a framework of reference.
To import the framework in you Eclipse Java project please refere to [this](http://stackoverflow.com/questions/3280353/how-to-import-a-jar-in-eclipse) article on Stack Overflow

### Instructions

You are building an application for maintaining user's stock portfolios. Your application would use a stock market service to retrieve stock prices from a real server (such as NASDAQ).

When it comes to testing your code, you wouldn't want to hit the real stock market server for fetching the stock prices. Instead, you would like some dummy price values. So, you need to mock the stock market service that returns dummy values without hitting the real server.


text:
namespace NLog.UnitTests
{
    using System;
    using System.Globalization;
    using System.Threading;
    using System.Diagnostics;
    using Xunit;

    public class NLogTraceListenerTests : NLogTestBase, IDisposable
    {
        private readonly CultureInfo previousCultureInfo;

        public NLogTraceListenerTests()
        {
            this.previousCultureInfo = Thread.CurrentThread.CurrentCulture;
            // set the culture info with the decimal separator (comma) different from InvariantCulture separator (point)
            Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
        }

        public void Dispose()
        {
            // restore previous culture info
            Thread.CurrentThread.CurrentCulture = this.previousCultureInfo;
        }

        [Fact]
        public void TraceWriteTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Debug' writeTo='debug' />
                    </rules>
                </nlog>");

            Debug.Listeners.Clear();
            Debug.Listeners.Add(new NLogTraceListener { Name = "Logger1" });

            Debug.Write("Hello");
            AssertDebugLastMessage("debug", "Logger1 Debug Hello");

            Debug.Write("Hello", "Cat1");
            AssertDebugLastMessage("debug", "Logger1 Debug Cat1: Hello");

            Debug.Write(3.1415);
            AssertDebugLastMessage("debug", string.Format("Logger1 Debug {0}", 3.1415));

            Debug.Write(3.1415, "Cat2");
            AssertDebugLastMessage("debug", string.Format("Logger1 Debug Cat2: {0}", 3.1415));
        }

        [Fact]
        public void TraceWriteLineTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Debug' writeTo='debug' />
                    </rules>
                </nlog>");

            Debug.Listeners.Clear();
            Debug.Listeners.Add(new NLogTraceListener { Name = "Logger1" });

            Debug.WriteLine("Hello");
            AssertDebugLastMessage("debug", "Logger1 Debug Hello");

            Debug.WriteLine("Hello", "Cat1");
            AssertDebugLastMessage("debug", "Logger1 Debug Cat1: Hello");

            Debug.WriteLine(3.1415);
            AssertDebugLastMessage("debug", string.Format("Logger1 Debug {0}", 3.1415));

            Debug.WriteLine(3.1415, "Cat2");
            AssertDebugLastMessage("debug", string.Format("Logger1 Debug Cat2: {0}", 3.1415));
        }

        [Fact]
        public void TraceWriteNonDefaultLevelTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Trace' writeTo='debug' />
                    </rules>
                </nlog>");

            Debug.Listeners.Clear();
            Debug.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace });

            Debug.Write("Hello");
            AssertDebugLastMessage("debug", "Logger1 Trace Hello");
        }

        [Fact]
        public void TraceConfiguration()
        {
            var listener = new NLogTraceListener();
            listener.Attributes.Add("defaultLogLevel", "Warn");
            listener.Attributes.Add("forceLogLevel", "Error");
            listener.Attributes.Add("autoLoggerName", "1");

            Assert.Equal(LogLevel.Warn, listener.DefaultLogLevel);
            Assert.Equal(LogLevel.Error, listener.ForceLogLevel);
            Assert.True(listener.AutoLoggerName);
        }

        [Fact]
        public void TraceFailTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Debug' writeTo='debug' />
                    </rules>
                </nlog>");

            Debug.Listeners.Clear();
            Debug.Listeners.Add(new NLogTraceListener { Name = "Logger1" });

            Debug.Fail("Message");
            AssertDebugLastMessage("debug", "Logger1 Error Message");

            Debug.Fail("Message", "Detailed Message");
            AssertDebugLastMessage("debug", "Logger1 Error Message Detailed Message");
        }

        [Fact]
        public void AutoLoggerNameTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Debug' writeTo='debug' />
                    </rules>
                </nlog>");

            Debug.Listeners.Clear();
            Debug.Listeners.Add(new NLogTraceListener { Name = "Logger1", AutoLoggerName = true });

            Debug.Write("Hello");
            AssertDebugLastMessage("debug", this.GetType().FullName + " Debug Hello");
        }

        [Fact]
        public void TraceDataTests()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message} ${event-context:EventID}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Trace' writeTo='debug' />
                    </rules>
                </nlog>");

            TraceSource ts = CreateTraceSource();
            ts.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace });

            ts.TraceData(TraceEventType.Critical, 123, 42);
            AssertDebugLastMessage("debug", "MySource1 Fatal 42 123");

            ts.TraceData(TraceEventType.Critical, 145, 42, 3.14, "foo");
            AssertDebugLastMessage("debug", string.Format("MySource1 Fatal 42, {0}, foo 145", 3.14.ToString(System.Globalization.CultureInfo.CurrentCulture)));
        }

#if MONO
        [Fact(Skip="Not working under MONO - not sure if unit test is wrong, or the code")]
#else
        [Fact]
#endif
        public void LogInformationTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message} ${event-context:EventID}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Trace' writeTo='debug' />
                    </rules>
                </nlog>");

            TraceSource ts = CreateTraceSource();
            ts.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace });

            ts.TraceInformation("Quick brown fox");
            AssertDebugLastMessage("debug", "MySource1 Info Quick brown fox 0");

            ts.TraceInformation("Mary had {0} lamb", "a little");
            AssertDebugLastMessage("debug", "MySource1 Info Mary had a little lamb 0");
        }

        [Fact]
        public void TraceEventTests()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message} ${event-context:EventID}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Trace' writeTo='debug' />
                    </rules>
                </nlog>");

            TraceSource ts = CreateTraceSource();
            ts.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace });

            ts.TraceEvent(TraceEventType.Information, 123, "Quick brown {0} jumps over the lazy {1}.", "fox", "dog");
            AssertDebugLastMessage("debug", "MySource1 Info Quick brown fox jumps over the lazy dog. 123");

            ts.TraceEvent(TraceEventType.Information, 123);
            AssertDebugLastMessage("debug", "MySource1 Info  123");

            ts.TraceEvent(TraceEventType.Verbose, 145, "Bar");
            AssertDebugLastMessage("debug", "MySource1 Trace Bar 145");

            ts.TraceEvent(TraceEventType.Error, 145, "Foo");
            AssertDebugLastMessage("debug", "MySource1 Error Foo 145");

            ts.TraceEvent(TraceEventType.Suspend, 145, "Bar");
            AssertDebugLastMessage("debug", "MySource1 Debug Bar 145");

            ts.TraceEvent(TraceEventType.Resume, 145, "Foo");
            AssertDebugLastMessage("debug", "MySource1 Debug Foo 145");

            ts.TraceEvent(TraceEventType.Warning, 145, "Bar");
            AssertDebugLastMessage("debug", "MySource1 Warn Bar 145");

            ts.TraceEvent(TraceEventType.Critical, 145, "Foo");
            AssertDebugLastMessage("debug", "MySource1 Fatal Foo 145");
        }

#if MONO
        [Fact(Skip="Not working under MONO - not sure if unit test is wrong, or the code")]
#else
        [Fact]
#endif
        public void ForceLogLevelTest()
        {
            LogManager.Configuration = CreateConfigurationFromString(@"
                <nlog>
                    <targets><target name='debug' type='Debug' layout='${logger} ${level} ${message} ${event-context:EventID}' /></targets>
                    <rules>
                        <logger name='*' minlevel='Trace' writeTo='debug' />
                    </rules>
                </nlog>");

            TraceSource ts = CreateTraceSource();
            ts.Listeners.Add(new NLogTraceListener { Name = "Logger1", DefaultLogLevel = LogLevel.Trace, ForceLogLevel = LogLevel.Warn });

            // force all logs to be Warn, DefaultLogLevel has no effect on TraceSource
            ts.TraceInformation("Quick brown fox");
            AssertDebugLastMessage("debug", "MySource1 Warn Quick brown fox 0");

            ts.TraceInformation("Mary had {0} lamb", "a little");
            AssertDebugLastMessage("debug", "MySource1 Warn Mary had a little lamb 0");
        }

        private static TraceSource CreateTraceSource()
        {
            var ts = new TraceSource("MySource1", SourceLevels.All);
#if MONO
            // for some reason needed on Mono
            ts.Switch = new SourceSwitch("MySource1", "Verbose");
            ts.Switch.Level = SourceLevels.All;
#endif
            return ts;
        }
    }
}

#endif


text:
/*
 * 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.
 */

import {AbstractUserManagementComponent} from '../../../abstract.user-management.component';
import {Component, ElementRef, EventEmitter, Injector, Output} from '@angular/core';
import {isUndefined} from 'util';
import {StringUtil} from '@common/util/string.util';
import {Alert} from '@common/util/alert.util';
import {CommonUtil} from '@common/util/common.util';

@Component({
  selector: 'app-create-user-management-members',
  templateUrl: './create-user-management-members.component.html'
})
export class CreateUserManagementMembersComponent extends AbstractUserManagementComponent {

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Private Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  // 멤버 모달 show hide 설정
  private _createModalShowFl: boolean = false;

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Protected Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  // id
  public userId: string;
  // email
  public email: string;
  // 이름
  public userName: string;

  // id flag
  public resultId: boolean;
  // email flag
  public resultEmail: boolean;
  // name flag
  public resultName: boolean;

  // id error message
  public idMessage: string;
  // email error message
  public emailMessage: string;
  // name error message
  public nameMessage: string;

  @Output()
  public createComplete: EventEmitter<any> = new EventEmitter();

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Constructor
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  // 생성자
  constructor(protected element: ElementRef,
              protected injector: Injector) {
    super(element, injector);
  }

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Method
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /**
   * init
   */
  public init(): void {
    // ui init
    this._initView();
    // 모달 show
    this._createModalShowFl = true;
  }

  /**
   * close
   */
  public createCancel(): void {
    // 모달 hide
    this._createModalShowFl = false;
  }

  /**
   * done
   */
  public createDone(): void {
    // validation
    if (this.doneValidation()) {
      // 로딩 show
      this.loadingShow();
      // 사용자에게 확인 이메일 전달
      this.membersService.createUser(this._getCreateUserParams())
        .then(() => {
          // alert
          Alert.success(this.translateService.instant('msg.mem.alert.name.create', {value: this.userName.trim()}));
          // 로딩 hide
          this.loadingHide();
          // 모달 hide
          this._createModalShowFl = false;
          this.createComplete.emit();
        })
        .catch((error) => {
          // alert
          Alert.error(error);
          // 로딩 hide
          this.loadingHide();
        })
    }
  }

  /**
   * init id validation
   */
  public initIdValidation(): void {
    this.resultId = undefined;
  }

  /**
   * init email validation
   */
  public initEmailValidation(): void {
    this.resultEmail = undefined;
  }

  /**
   * init name validation
   */
  public initNameValidation(): void {
    this.resultName = undefined;
  }

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Method - getter
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /**
   * modal show flag
   * @returns {boolean}
   */
  public get getShowFlag(): boolean {
    return this._createModalShowFl;
  }

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Method - validation
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /**
   * id validation
   */
  public idValidation(): void {
    // 아이디가 비어 있다면
    if (isUndefined(this.userId) || this.userId.trim() === '') {
      this.resultId = false;
      this.idMessage = this.translateService.instant('LOGIN_JOIN_INPUT_ID');
      return;
    }
    // id 형식 확인
    if (!StringUtil.isId(this.userId) || CommonUtil.getByte(this.userId.trim()) < 3 || CommonUtil.getByte(this.userId.trim()) > 20) {
      this.resultId = false;
      this.idMessage = this.translateService.instant('LOGIN_JOIN_VALID_ID');
      return;
    }
    // 중복 확인
    this._checkDuplicateId(this.userId.trim());
  }

  /**
   * email validation
   */
  public emailValidation(): void {
    // 아이디가 비어 있다면
    if (isUndefined(this.email) || this.email.trim() === '') {
      this.resultEmail = false;
      this.emailMessage = this.translateService.instant('LOGIN_JOIN_INPUT_EMAIL');
      return;
    }
    // 이메일 형식 확인
    if (!StringUtil.isEmail(this.email)) {
      this.resultEmail = false;
      this.emailMessage = this.translateService.instant('LOGIN_JOIN_VALID_EMAIL');
      return;
    }
    // 중복 확인
    this._checkDuplicateEmail(this.email.trim());
  }

  /**
   * name validation
   */
  public nameValidation(): void {
    // 이름이 비어 있다면
    if (isUndefined(this.userName) || this.userName.trim() === '') {
      this.resultName = false;
      this.nameMessage = this.translateService.instant('LOGIN_JOIN_INPUT_NAME');
      return;
    }
    // 이름 길이 체크
    if (CommonUtil.getByte(this.userName.trim()) > 150) {
      this.resultName = false;
      this.nameMessage = this.translateService.instant('msg.groups.alert.name.len');
      return;
    }
    this.resultName = true;
  }

  /**
   * done validation
   * @returns {boolean}
   */
  public doneValidation(): boolean {
    // 이름
    if (!this.resultName) {
      this.nameValidation();
      return false;
    }
    // 아이디
    if (!this.resultId) {
      this.idValidation();
      return false;
    }
    // 이메일
    if (!this.resultEmail) {
      this.emailValidation();
      return false;
    }
    return this.resultEmail && this.resultId && this.resultName;
  }

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Protected Method
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Private Method
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /**
   * init view
   * @private
   */
  private _initView(): void {
    // 초기화
    this.userId = '';
    this.email = '';
    this.userName = '';
    this.resultName = undefined;
    this.resultId = undefined;
    this.resultEmail = undefined;
  }

  /**
   * 아이디 중복 체크
   * @param {string} id
   * @private
   */
  private _checkDuplicateId(id: string): void {
    this.membersService.getResultDuplicatedUserName(id)
      .then((result) => {
        // 아이디 사용 가능한 여부
        this.resultId = !result['duplicated'];
        // 아이디가 중복 이라면
        if (result['duplicated']) {
          this.idMessage = this.translateService.instant('LOGIN_JOIN_USE_ID');
        }
      });
  }

  /**
   * 이메일 중복체크
   * @param {string} email
   * @private
   */
  private _checkDuplicateEmail(email: string): void {
    this.membersService.getResultDuplicatedEmail(email)
      .then((result) => {
        // 이메일 사용 가능한 여부
        this.resultEmail = !result['duplicated'];
        // 이메일이 중복 이라면
        if (result['duplicated']) {
          this.emailMessage = this.translateService.instant('LOGIN_JOIN_USE_EMAIL');
        }
      });
  }

  /**
   * 사용자 생성시 필요한 파라메터
   * @returns {Object}
   * @private
   */
  private _getCreateUserParams(): object {
    return {email: this.email.trim(), username: this.userId.trim(), fullName: this.userName.trim()};
  }
}


text:
define(function(require, exports, module) {

exports.isDark = false;
exports.cssClass = "ace-jett";
exports.cssText = require("../requirejs/text!./jett.css");

var dom = require("../lib/dom");
dom.importCssString(exports.cssText, exports.cssClass);
});


text:
package com.gemstone.gemfire.management.internal.beans.stats;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
import com.gemstone.gemfire.i18n.LogWriterI18n;
import com.gemstone.gemfire.management.internal.FederationComponent;
import com.gemstone.gemfire.management.internal.ManagementConstants;

/**
 *
 * @author rishim
 *
 */
public class StatsAggregator {

  private Map<String, Class<?>> typeMap;

  private Map<String, AtomicReference<Number>> aggregateMap;

  private LogWriterI18n logger;

  public StatsAggregator(Map<String, Class<?>> typeMap) {
    this.typeMap = typeMap;
    this.aggregateMap = new HashMap<String, AtomicReference<Number>>();
    this.logger = InternalDistributedSystem.getLoggerI18n();
    initAggregateMap();
  }

  /**
   * Initialize all counters to 0;
   */
  private void initAggregateMap() {
    Iterator<String> it = typeMap.keySet().iterator();
    while (it.hasNext()) {
      AtomicReference<Number> ref = null;
      String attribute = it.next();
      Class<?> classzz = typeMap.get(attribute);
      if (classzz == Long.TYPE) {
        ref = new AtomicReference<Number>(new Long(0L));
      } else if (classzz == Integer.TYPE) {
        ref = new AtomicReference<Number>(new Integer(0));
      } else if (classzz == Float.TYPE) {
        ref = new AtomicReference<Number>(new Float(0F));
      } else if (classzz == Double.TYPE) {
        ref = new AtomicReference<Number>(new Double(0D));

      }

      aggregateMap.put(attribute, ref);
    }
  }

  public void aggregate(FederationComponent newComp,
      FederationComponent oldComp) {

    Map<String, Object> newState = (newComp != null ? newComp.getObjectState()
        : null);
    Map<String, Object> oldState;

    if (oldComp != null && oldComp.getOldState().size() > 0) {
      oldState = oldComp.getOldState();
    } else {
      oldState = (oldComp != null ? oldComp.getObjectState() : null);
    }

    String attribute = null;
    try {
      if (typeMap != null && !typeMap.isEmpty()) {
        for (Map.Entry<String, Class<?>> typeEntry: typeMap.entrySet()) {
          attribute = typeEntry.getKey();

          Object newVal = newState != null ? newState.get(attribute) : null;
          if (newVal != null) {
            Object oldVal = null;

            if (oldState != null) {
              oldVal = oldState.get(attribute);
            }

            Class<?> classzz = typeEntry.getValue();
            if (classzz == Long.TYPE) {
              if (oldVal == null) {
                oldVal = new Long(0L);
              }
              incLong(attribute, (Long) newVal, (Long) oldVal);
            } else if (classzz == Integer.TYPE) {
              if (oldVal == null) {
                oldVal =  new Integer(0);
              }
              incInt(attribute, (Integer) newVal, (Integer) oldVal);
            } else if (classzz == Float.TYPE) {
              if (oldVal == null) {
                oldVal = new Float(0F);
              }
              incFloat(attribute, (Float) newVal, (Float) oldVal);
            } else if (classzz == Double.TYPE) {
              if (oldVal == null) {
                oldVal = new Double(0D);
              }
              incDouble(attribute, (Double) newVal, (Double) oldVal);

            }

          } else if (oldState != null && newState == null) {
            Object oldVal = oldState.get(attribute);
            if(oldVal != null){
              Class<?> classzz = typeEntry.getValue();
              if (classzz == Long.TYPE) {
                decLong(attribute, (Long) oldVal);
              } else if (classzz == Integer.TYPE) {
                decInt(attribute, (Integer) oldVal);
              } else if (classzz == Float.TYPE) {
                decFloat(attribute, (Float) oldVal);
              } else if (classzz == Double.TYPE) {
                decDouble(attribute, (Double) oldVal);

              }
            }

          }

        }

      }
    } catch (Exception e) {
        if(logger.fineEnabled()){
          logger.fine("Exception while processing attribute " + attribute);
          logger.fine(e);
        }
    }

  }

  public Integer getIntValue(String attributeName) {
    int val = aggregateMap.get(attributeName).get().intValue();
    return val < 0 ? ManagementConstants.NOT_AVAILABLE_INT : val;
  }

  public Long getLongValue(String attributeName) {
    long val = aggregateMap.get(attributeName).get().longValue();
    return val < 0 ? ManagementConstants.NOT_AVAILABLE_LONG : val;
  }

  public Float getFloatValue(String attributeName) {
    float val = aggregateMap.get(attributeName).get().floatValue();
    return val < 0 ? ManagementConstants.NOT_AVAILABLE_FLOAT : val;
  }

  public Double getDoubleValue(String attributeName) {
    double val = aggregateMap.get(attributeName).get().doubleValue();
    return val < 0 ? ManagementConstants.NOT_AVAILABLE_DOUBLE : val;
  }

  public void incLong(String attributeName, Long newVal, Long oldVal) {
    if (newVal.equals(oldVal)) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    for (;;) {
      Number expectedVal = ar.get();
      Number curVal = expectedVal.longValue() + (newVal - oldVal);
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void incInt(String attributeName, Integer newVal, Integer oldVal) {
    if (newVal.equals(oldVal)) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    for (;;) {
      Number expectedVal = ar.get();
      Number curVal = expectedVal.intValue() + (newVal - oldVal);
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void incFloat(String attributeName, Float newVal, Float oldVal) {
    if (newVal.equals(oldVal)) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    for (;;) {
      Number expectedVal = ar.get();
      Number curVal = expectedVal.floatValue() + (newVal - oldVal);
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void incDouble(String attributeName, Double newVal, Double oldVal) {
    if (newVal.equals(oldVal)) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    for (;;) {
      Number expectedVal = ar.get();
      Number curVal = expectedVal.doubleValue() + (newVal - oldVal);
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void decLong(String attributeName,Long oldVal) {
    if (oldVal == 0) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    Number curVal;
    for (;;) {
      Number expectedVal = ar.get();
      if (expectedVal.longValue() != 0) {
        curVal = expectedVal.longValue() - oldVal;
      } else {
        return;
      }
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void decInt(String attributeName,Integer oldVal) {
    if (oldVal == 0) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    Number curVal;
    for (;;) {
      Number expectedVal = ar.get();
      if (expectedVal.intValue() != 0) {
        curVal = expectedVal.intValue() - oldVal;
      } else {
        return;
      }
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void decFloat(String attributeName,Float oldVal) {
    if (oldVal == 0) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    Number curVal;
    for (;;) {
      Number expectedVal = ar.get();
      if (expectedVal.floatValue() != 0) {
        curVal = expectedVal.floatValue() - oldVal;
      } else {
        return;
      }
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }

  public void decDouble(String attributeName,Double oldVal) {
    if (oldVal == 0) {
      return;
    }
    AtomicReference<Number> ar = aggregateMap.get(attributeName);
    Number curVal;
    for (;;) {
      Number expectedVal = ar.get();
      if (expectedVal.doubleValue() != 0) {
        curVal = expectedVal.doubleValue() - oldVal;
      } else {
        return;
      }
      if (ar.compareAndSet(expectedVal, curVal)) {
        return;
      }
    }
  }
}


text:
<?php
/**
* Changes Session of Type Panel to Sessions of type Workshop
*
* @package FoIGF
*/
class PanelToWorkshopTask extends BuildTask{

	protected $title = "Switch Panel Discussions to Workshops";

	protected $description = "Switch Panel Discussions to Workshops";

	function run($request){
		$count = 0;

		foreach(MeetingSession::get() as $session){
			if($session->TypeID == 2){
				$session->TypeID = 4;
				$session->write();
				echo $session->Title;
			}
		}

	}
}


text:
package org.mockito.internal.configuration.injection.filter;

import static org.mockito.internal.exceptions.Reporter.cannotInjectDependency;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;

import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.util.reflection.BeanPropertySetter;
import org.mockito.plugins.MemberAccessor;

/**
 * This node returns an actual injecter which will be either :
 *
 *

 *
an {@link OngoingInjector} that do nothing if a candidate couldn't be found

 *
an {@link OngoingInjector} that will try to inject the candidate trying first the property setter then if not possible try the field access

 *

 */
public class TerminalMockCandidateFilter implements MockCandidateFilter {
    public OngoingInjector filterCandidate(
            final Collection<Object> mocks,
            final Field candidateFieldToBeInjected,
            final List<Field> allRemainingCandidateFields,
            final Object injectee) {
        if (mocks.size() == 1) {
            final Object matchingMock = mocks.iterator().next();

            MemberAccessor accessor = Plugins.getMemberAccessor();
            return () -> {
                try {
                    if (!new BeanPropertySetter(injectee, candidateFieldToBeInjected)
                            .set(matchingMock)) {
                        accessor.set(candidateFieldToBeInjected, injectee, matchingMock);
                    }
                } catch (RuntimeException | IllegalAccessException e) {
                    throw cannotInjectDependency(candidateFieldToBeInjected, matchingMock, e);
                }
                return matchingMock;
            };
        }

        return OngoingInjector.nop;
    }
}


text:
<readable><title>3282897060_8c584e2ce8</title><content>
A man who is resting his head on his hand .
A person wearing a white shirt sits and makes a face .
A woman is sitting up asleep with her head resting on her hand .
A woman resting her face on her hand .
This man appears to be sleeping while resting his head on his hand .
</content></readable>


text:
layout: post
title: All Links Lead to Wikipedia
summary: In which we discuss batman, super hero movies, Google's new logo, Windows 10, cameras, and wikipedia links.
link: https://s3.amazonaws.com/talkingdudes/2015-09-16-12.mp3
size: 38668530
length: '40:15'
permalink: /12
---

Sorry, about the audio quality this week, it will be much better next time.

- [Inglourious Basterds](http://www.amazon.com/gp/product/B002YCVX5S/?tag=adahar09-20)
- [Batman & Robin](http://www.amazon.com/gp/product/B001XVBGGM/?tag=adahar09-20)
- [John Glover](http://www.imdb.com/name/nm0001278/?ref_=tt_cl_t8)
- [Batman v Superman: Dawn of Justice](https://en.wikipedia.org/wiki/Batman_v_Superman:_Dawn_of_Justice)
- [What's Eating Gilbert Grape](http://www.amazon.com/gp/product/B00AEBB9F0/?tag=adahar09-20)
- [Google's New Logo](http://googleblog.blogspot.com/2015/09/google-update.html)
- [Windows 10](https://en.wikipedia.org/wiki/Windows_10)
- [Android watches work on iOS](http://techcrunch.com/2015/08/31/android-wear-for-ios/)
- [Ricoh Theta](http://www.amazon.com/gp/product/B00OZCM70K/?tag=adahar09-20)


text:
/*	$NetBSD: svr4_statvfs.h,v 1.3 1998/09/04 19:54:40 christos Exp $	 */

/*-
 * Copyright (c) 1994 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Christos Zoulas.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef	_SVR4_STATVFS_H_
#define	_SVR4_STATVFS_H_

typedef struct svr4_statvfs {
	u_long			f_bsize;
	u_long			f_frsize;
	svr4_fsblkcnt_t		f_blocks;
	svr4_fsblkcnt_t		f_bfree;
	svr4_fsblkcnt_t		f_bavail;
	svr4_fsblkcnt_t		f_files;
	svr4_fsblkcnt_t		f_ffree;
	svr4_fsblkcnt_t		f_favail;
	u_long			f_fsid;
	char			f_basetype[16];
	u_long			f_flag;
	u_long			f_namemax;
	char			f_fstr[32];
	u_long			f_filler[16];
} svr4_statvfs_t;

typedef struct svr4_statvfs64 {
	u_long			f_bsize;
	u_long			f_frsize;
	svr4_fsblkcnt64_t	f_blocks;
	svr4_fsblkcnt64_t	f_bfree;
	svr4_fsblkcnt64_t	f_bavail;
	svr4_fsblkcnt64_t	f_files;
	svr4_fsblkcnt64_t	f_ffree;
	svr4_fsblkcnt64_t	f_favail;
	u_long			f_fsid;
	char			f_basetype[16];
	u_long			f_flag;
	u_long			f_namemax;
	char			f_fstr[32];
	u_long			f_filler[16];
} svr4_statvfs64_t;

#define	SVR4_ST_RDONLY	0x01
#define	SVR4_ST_NOSUID	0x02
#define	SVR4_ST_NOTRUNC	0x04

#endif /* !_SVR4_STATVFS_H_ */


text:
package io.gravitee.gateway.services.ratelimit;

import io.gravitee.repository.ratelimit.api.RateLimitRepository;
import io.gravitee.repository.ratelimit.api.RateLimitService;
import io.gravitee.repository.ratelimit.model.RateLimit;
import io.reactivex.Single;
import java.util.function.Supplier;

/**
 * @author David BRASSELY (david.brassely at graviteesource.com)
 * @author GraviteeSource Team
 */
public class DefaultRateLimitService implements RateLimitService {

    private RateLimitRepository<RateLimit> rateLimitRepository;
    private RateLimitRepository<RateLimit> asyncRateLimitRepository;

    private RateLimitRepository<RateLimit> getRateLimitRepository(boolean async) {
        return (async) ? asyncRateLimitRepository : rateLimitRepository;
    }

    public RateLimitRepository<RateLimit> getAsyncRateLimitRepository() {
        return asyncRateLimitRepository;
    }

    public void setAsyncRateLimitRepository(RateLimitRepository<RateLimit> asyncRateLimitRepository) {
        this.asyncRateLimitRepository = asyncRateLimitRepository;
    }

    public RateLimitRepository getRateLimitRepository() {
        return rateLimitRepository;
    }

    public void setRateLimitRepository(RateLimitRepository<RateLimit> rateLimitRepository) {
        this.rateLimitRepository = rateLimitRepository;
    }

    @Override
    public Single<RateLimit> incrementAndGet(String key, long weight, boolean async, Supplier<RateLimit> supplier) {
        try {
            return getRateLimitRepository(async).incrementAndGet(key, weight, supplier).map(rateLimit -> rateLimit);
        } catch (Exception ex) {
            return Single.error(ex);
        }
    }
}


text:
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include <string.h>
#include "util/coding.h"
#include "util/hash.h"

// The FALLTHROUGH_INTENDED macro can be used to annotate implicit fall-through
// between switch labels. The real definition should be provided externally.
// This one is a fallback version for unsupported compilers.
#ifndef FALLTHROUGH_INTENDED
#define FALLTHROUGH_INTENDED do { } while (0)
#endif

namespace leveldb {

uint32_t Hash(const char* data, size_t n, uint32_t seed) {
  // Similar to murmur hash
  const uint32_t m = 0xc6a4a793;
  const uint32_t r = 24;
  const char* limit = data + n;
  uint32_t h = seed ^ (n * m);

  // Pick up four bytes at a time
  while (data + 4 <= limit) {
    uint32_t w = DecodeFixed32(data);
    data += 4;
    h += w;
    h *= m;
    h ^= (h >> 16);
  }

  // Pick up remaining bytes
  switch (limit - data) {
    case 3:
      h += data[2] << 16;
      FALLTHROUGH_INTENDED;
    case 2:
      h += data[1] << 8;
      FALLTHROUGH_INTENDED;
    case 1:
      h += data[0];
      h *= m;
      h ^= (h >> r);
      break;
  }
  return h;
}

}  // namespace leveldb


text:
package org.apache.camel.dataformat.bindy.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * This annotation allows to define during the marshaling process how a message must be reconstruct
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Section {

    /**
     * Number of the section
     */
    int number();
}


text:
package request

import (
	"context"
	"testing"
	"time"

	"github.com/golang/mock/gomock"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/yarpc/api/transport"
	"go.uber.org/yarpc/api/transport/transporttest"
	"go.uber.org/yarpc/api/x/introspection"
)

func TestCall(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	ctx := context.Background()
	req := newValidTestRequest()

	t.Run("unary", func(t *testing.T) {
		out := transporttest.NewMockUnaryOutbound(ctrl)
		validatorOut := UnaryValidatorOutbound{UnaryOutbound: out}

		ctx, cancel := context.WithTimeout(ctx, time.Second)
		defer cancel()
		out.EXPECT().Call(ctx, req).Return(nil, nil)

		_, err := validatorOut.Call(ctx, req)
		require.NoError(t, err)
	})

	t.Run("oneway", func(t *testing.T) {
		out := transporttest.NewMockOnewayOutbound(ctrl)
		validatorOut := OnewayValidatorOutbound{OnewayOutbound: out}

		ctx, cancel := context.WithTimeout(ctx, time.Second)
		defer cancel()
		out.EXPECT().CallOneway(ctx, req).Return(nil, nil)

		_, err := validatorOut.CallOneway(ctx, req)
		require.NoError(t, err)
	})
}

func TestCallErrors(t *testing.T) {
	ctrl := gomock.NewController(t)
	validatorOut := UnaryValidatorOutbound{UnaryOutbound: transporttest.NewMockUnaryOutbound(ctrl)}
	validatorOutOneway := OnewayValidatorOutbound{OnewayOutbound: transporttest.NewMockOnewayOutbound(ctrl)}

	tests := []struct {
		name string
		ctx  context.Context
		req  *transport.Request
	}{
		{
			name: "invalid context",
			ctx:  context.Background(), // no deadline
			req:  newValidTestRequest(),
		},
		{
			name: "invalid request",
			req:  &transport.Request{},
		},
	}

	for _, tt := range tests {
		t.Run("unary: "+tt.name, func(t *testing.T) {
			res, err := validatorOut.Call(tt.ctx, tt.req)
			assert.Nil(t, res)
			assert.Error(t, err, "expected error from invalid request")
		})

		t.Run("oneway: "+tt.name, func(t *testing.T) {
			ack, err := validatorOutOneway.CallOneway(tt.ctx, tt.req)
			assert.Nil(t, ack)
			assert.Error(t, err, "expected error from invalid request")
		})

		// Streaming requests without deadlines are valid, so this this test
		// table does not apply.
	}
}

func TestIntrospect(t *testing.T) {
	ctrl := gomock.NewController(t)

	t.Run("unary", func(t *testing.T) {
		validatorOut := UnaryValidatorOutbound{UnaryOutbound: transporttest.NewMockUnaryOutbound(ctrl)}
		assert.Equal(t, introspection.OutboundStatusNotSupported, validatorOut.Introspect())
	})

	t.Run("oneway", func(t *testing.T) {
		validatorOut := OnewayValidatorOutbound{OnewayOutbound: transporttest.NewMockOnewayOutbound(ctrl)}
		assert.Equal(t, introspection.OutboundStatusNotSupported, validatorOut.Introspect())
	})

	t.Run("stream", func(t *testing.T) {
		validatorOut := StreamValidatorOutbound{StreamOutbound: transporttest.NewMockStreamOutbound(ctrl)}
		assert.Equal(t, introspection.OutboundStatusNotSupported, validatorOut.Introspect())
	})
}

func newValidTestRequest() *transport.Request {
	return &transport.Request{
		Service:   "service",
		Procedure: "procedure",
		Caller:    "caller",
		Encoding:  "encoding",
	}
}

func TestStreamValidate(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	ctx := context.Background()
	req := &transport.StreamRequest{
		Meta: &transport.RequestMeta{
			Service:   "service",
			Procedure: "proc",
			Caller:    "caller",
			Encoding:  "raw",
		},
	}
	stream, err := transport.NewClientStream(transporttest.NewMockStreamCloser(mockCtrl))
	require.NoError(t, err)

	out := transporttest.NewMockStreamOutbound(mockCtrl)
	out.EXPECT().CallStream(ctx, req).Times(1).Return(stream, nil)

	validator := StreamValidatorOutbound{StreamOutbound: out}

	gotStream, gotErr := validator.CallStream(ctx, req)

	assert.NoError(t, gotErr)
	assert.Equal(t, stream, gotStream)
}

func TestStreamValidateError(t *testing.T) {
	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()

	ctx := context.Background()
	req := &transport.StreamRequest{
		Meta: &transport.RequestMeta{
			Service:  "service",
			Caller:   "caller",
			Encoding: "raw",
		},
	}

	out := transporttest.NewMockStreamOutbound(mockCtrl)

	validator := StreamValidatorOutbound{StreamOutbound: out}

	_, gotErr := validator.CallStream(ctx, req)

	assert.Error(t, gotErr)
}


text:
package remote

import (
	"time"

	"golang.org/x/net/context"

	internalapi "k8s.io/kubernetes/pkg/kubelet/apis/cri"
	runtimeapi "k8s.io/kubernetes/pkg/kubelet/apis/cri/v1alpha1/runtime"
	"k8s.io/kubernetes/pkg/kubelet/dockershim"
	utilexec "k8s.io/utils/exec"
)

// DockerService is the interface implement CRI remote service server.
type DockerService interface {
	runtimeapi.RuntimeServiceServer
	runtimeapi.ImageServiceServer
}

// dockerService uses dockershim service to implement DockerService.
// Notice that the contexts in the functions are not used now.
// TODO(random-liu): Change the dockershim service to support context, and implement
// internal services and remote services with the dockershim service.
type dockerService struct {
	runtimeService internalapi.RuntimeService
	imageService   internalapi.ImageManagerService
}

func NewDockerService(s dockershim.DockerService) DockerService {
	return &dockerService{runtimeService: s, imageService: s}
}

func (d *dockerService) Version(ctx context.Context, r *runtimeapi.VersionRequest) (*runtimeapi.VersionResponse, error) {
	return d.runtimeService.Version(r.Version)
}

func (d *dockerService) Status(ctx context.Context, r *runtimeapi.StatusRequest) (*runtimeapi.StatusResponse, error) {
	status, err := d.runtimeService.Status()
	if err != nil {
		return nil, err
	}
	return &runtimeapi.StatusResponse{Status: status}, nil
}

func (d *dockerService) RunPodSandbox(ctx context.Context, r *runtimeapi.RunPodSandboxRequest) (*runtimeapi.RunPodSandboxResponse, error) {
	podSandboxId, err := d.runtimeService.RunPodSandbox(r.GetConfig())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.RunPodSandboxResponse{PodSandboxId: podSandboxId}, nil
}

func (d *dockerService) StopPodSandbox(ctx context.Context, r *runtimeapi.StopPodSandboxRequest) (*runtimeapi.StopPodSandboxResponse, error) {
	err := d.runtimeService.StopPodSandbox(r.PodSandboxId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.StopPodSandboxResponse{}, nil
}

func (d *dockerService) RemovePodSandbox(ctx context.Context, r *runtimeapi.RemovePodSandboxRequest) (*runtimeapi.RemovePodSandboxResponse, error) {
	err := d.runtimeService.RemovePodSandbox(r.PodSandboxId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.RemovePodSandboxResponse{}, nil
}

func (d *dockerService) PodSandboxStatus(ctx context.Context, r *runtimeapi.PodSandboxStatusRequest) (*runtimeapi.PodSandboxStatusResponse, error) {
	podSandboxStatus, err := d.runtimeService.PodSandboxStatus(r.PodSandboxId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.PodSandboxStatusResponse{Status: podSandboxStatus}, nil
}

func (d *dockerService) ListPodSandbox(ctx context.Context, r *runtimeapi.ListPodSandboxRequest) (*runtimeapi.ListPodSandboxResponse, error) {
	items, err := d.runtimeService.ListPodSandbox(r.GetFilter())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ListPodSandboxResponse{Items: items}, nil
}

func (d *dockerService) CreateContainer(ctx context.Context, r *runtimeapi.CreateContainerRequest) (*runtimeapi.CreateContainerResponse, error) {
	containerId, err := d.runtimeService.CreateContainer(r.PodSandboxId, r.GetConfig(), r.GetSandboxConfig())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.CreateContainerResponse{ContainerId: containerId}, nil
}

func (d *dockerService) StartContainer(ctx context.Context, r *runtimeapi.StartContainerRequest) (*runtimeapi.StartContainerResponse, error) {
	err := d.runtimeService.StartContainer(r.ContainerId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.StartContainerResponse{}, nil
}

func (d *dockerService) StopContainer(ctx context.Context, r *runtimeapi.StopContainerRequest) (*runtimeapi.StopContainerResponse, error) {
	err := d.runtimeService.StopContainer(r.ContainerId, r.Timeout)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.StopContainerResponse{}, nil
}

func (d *dockerService) RemoveContainer(ctx context.Context, r *runtimeapi.RemoveContainerRequest) (*runtimeapi.RemoveContainerResponse, error) {
	err := d.runtimeService.RemoveContainer(r.ContainerId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.RemoveContainerResponse{}, nil
}

func (d *dockerService) ListContainers(ctx context.Context, r *runtimeapi.ListContainersRequest) (*runtimeapi.ListContainersResponse, error) {
	containers, err := d.runtimeService.ListContainers(r.GetFilter())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ListContainersResponse{Containers: containers}, nil
}

func (d *dockerService) ContainerStatus(ctx context.Context, r *runtimeapi.ContainerStatusRequest) (*runtimeapi.ContainerStatusResponse, error) {
	status, err := d.runtimeService.ContainerStatus(r.ContainerId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ContainerStatusResponse{Status: status}, nil
}

func (d *dockerService) UpdateContainerResources(ctx context.Context, r *runtimeapi.UpdateContainerResourcesRequest) (*runtimeapi.UpdateContainerResourcesResponse, error) {
	err := d.runtimeService.UpdateContainerResources(r.ContainerId, r.Linux)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.UpdateContainerResourcesResponse{}, nil
}

func (d *dockerService) ExecSync(ctx context.Context, r *runtimeapi.ExecSyncRequest) (*runtimeapi.ExecSyncResponse, error) {
	stdout, stderr, err := d.runtimeService.ExecSync(r.ContainerId, r.Cmd, time.Duration(r.Timeout)*time.Second)
	var exitCode int32
	if err != nil {
		exitError, ok := err.(utilexec.ExitError)
		if !ok {
			return nil, err
		}
		exitCode = int32(exitError.ExitStatus())
	}
	return &runtimeapi.ExecSyncResponse{
		Stdout:   stdout,
		Stderr:   stderr,
		ExitCode: exitCode,
	}, nil
}

func (d *dockerService) Exec(ctx context.Context, r *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) {
	return d.runtimeService.Exec(r)
}

func (d *dockerService) Attach(ctx context.Context, r *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error) {
	return d.runtimeService.Attach(r)
}

func (d *dockerService) PortForward(ctx context.Context, r *runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) {
	return d.runtimeService.PortForward(r)
}

func (d *dockerService) UpdateRuntimeConfig(ctx context.Context, r *runtimeapi.UpdateRuntimeConfigRequest) (*runtimeapi.UpdateRuntimeConfigResponse, error) {
	err := d.runtimeService.UpdateRuntimeConfig(r.GetRuntimeConfig())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.UpdateRuntimeConfigResponse{}, nil
}

func (d *dockerService) ListImages(ctx context.Context, r *runtimeapi.ListImagesRequest) (*runtimeapi.ListImagesResponse, error) {
	images, err := d.imageService.ListImages(r.GetFilter())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ListImagesResponse{Images: images}, nil
}

func (d *dockerService) ImageStatus(ctx context.Context, r *runtimeapi.ImageStatusRequest) (*runtimeapi.ImageStatusResponse, error) {
	image, err := d.imageService.ImageStatus(r.GetImage())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ImageStatusResponse{Image: image}, nil
}

func (d *dockerService) PullImage(ctx context.Context, r *runtimeapi.PullImageRequest) (*runtimeapi.PullImageResponse, error) {
	image, err := d.imageService.PullImage(r.GetImage(), r.GetAuth())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.PullImageResponse{ImageRef: image}, nil
}

func (d *dockerService) RemoveImage(ctx context.Context, r *runtimeapi.RemoveImageRequest) (*runtimeapi.RemoveImageResponse, error) {
	err := d.imageService.RemoveImage(r.GetImage())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.RemoveImageResponse{}, nil
}

// ImageFsInfo returns information of the filesystem that is used to store images.
func (d *dockerService) ImageFsInfo(ctx context.Context, r *runtimeapi.ImageFsInfoRequest) (*runtimeapi.ImageFsInfoResponse, error) {
	filesystems, err := d.imageService.ImageFsInfo()
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ImageFsInfoResponse{ImageFilesystems: filesystems}, nil
}

func (d *dockerService) ContainerStats(ctx context.Context, r *runtimeapi.ContainerStatsRequest) (*runtimeapi.ContainerStatsResponse, error) {
	stats, err := d.runtimeService.ContainerStats(r.ContainerId)
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ContainerStatsResponse{Stats: stats}, nil
}

func (d *dockerService) ListContainerStats(ctx context.Context, r *runtimeapi.ListContainerStatsRequest) (*runtimeapi.ListContainerStatsResponse, error) {
	stats, err := d.runtimeService.ListContainerStats(r.GetFilter())
	if err != nil {
		return nil, err
	}
	return &runtimeapi.ListContainerStatsResponse{Stats: stats}, nil
}


text:
.class public final Lcom/android/server/EngineeringModeService$SystemApplication;
.super Lcom/android/server/EngineeringModeService$EMClient;
.source "EngineeringModeService.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/server/EngineeringModeService;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x11
    name = "SystemApplication"
.end annotation

# instance fields
.field final synthetic this$0:Lcom/android/server/EngineeringModeService;

# direct methods
.method public constructor <init>(Lcom/android/server/EngineeringModeService;Ljava/lang/String;I)V
    .locals 0

    iput-object p1, p0, Lcom/android/server/EngineeringModeService$SystemApplication;->this$0:Lcom/android/server/EngineeringModeService;

    invoke-direct {p0, p1, p2, p3}, Lcom/android/server/EngineeringModeService$EMClient;-><init>(Lcom/android/server/EngineeringModeService;Ljava/lang/String;I)V

    return-void
.end method

# virtual methods
.method public isEmClient(Ljava/lang/String;ILjava/lang/Integer;)Z
    .locals 1

    invoke-virtual {p0, p1}, Lcom/android/server/EngineeringModeService$SystemApplication;->compareName(Ljava/lang/String;)Z

    move-result v0

    if-eqz v0, :cond_0

    invoke-virtual {p0, p2}, Lcom/android/server/EngineeringModeService$SystemApplication;->compareUid(I)Z

    move-result v0

    if-eqz v0, :cond_0

    invoke-virtual {p0, p3}, Lcom/android/server/EngineeringModeService$SystemApplication;->compareModes(Ljava/lang/Integer;)Z

    move-result v0

    if-eqz v0, :cond_0

    invoke-virtual {p0, p1, p2}, Lcom/android/server/EngineeringModeService$SystemApplication;->checkSignature(Ljava/lang/String;I)Z

    move-result v0

    :goto_0
    return v0

    :cond_0
    const/4 v0, 0x0

    goto :goto_0
.end method


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ProxyEndpoint name="default">
    <Description/>
    <PreFlow name="PreFlow">
        <Request>
            <Step>
                <Condition>request.verb = "OPTIONS"</Condition>
                <Name>Cors-preflighted</Name>
            </Step>
            <Step>
                <Name>Verify.ConsentAppAPIKey</Name>
            </Step>
        </Request>
        <Response/>
    </PreFlow>
    <Flows>
        <Flow name="get application tx session">
            <Description/>
            <Request>
                <Step>
                    <Name>Extract-Transaction-session-id</Name>
                </Step>
                <Step>
                    <Name>Lookup-Cache-Application-authorization-transaction-session</Name>
                </Step>
                <Step>
                    <Condition>(auth.transaction.session.id = null or auth.transaction.session.id = "") or (transaction.session.Payload = null) or (transaction.session.Payload = "")</Condition>
                    <Name>Error-Invalid-authorization-transaction-session</Name>
                </Step>
            </Request>
            <Response>
                <Step>
                    <Name>Ext-Extract-Application-Session</Name>
                </Step>
                <Step>
                    <Name>Assign-TransactionInfo-response</Name>
                </Step>
            </Response>
            <Condition>(proxy.pathsuffix MatchesPath "/transactions/{auth.transaction.session.id}") and (request.verb = "GET")</Condition>
        </Flow>
    </Flows>
    <PostFlow name="PostFlow">
        <Request/>
        <Response/>
    </PostFlow>
    <HTTPProxyConnection>
        <BasePath>/internal/apis/v1/session</BasePath>
        <VirtualHost>secure</VirtualHost>
    </HTTPProxyConnection>
    <RouteRule name="noroute"/>
</ProxyEndpoint>


text:
#include <easycc/EasyCCPro.h>
#include <calculator/Calculator.h>
#include <iostream>
#include <getopt.h>

// Hold output file
std::string outputFile;

// Hold input files
std::vector<std::string> inputFiles;

/**
 * Print program usage
 */
void printUsage() {
    std::cout
            << "calculator - EasyCC example" << std::endl
            << "Usage: calculator [OPTION]... [FILE]..." << std::endl
            << "\t-o, --output\t\t\tOutput file" << std::endl
            << "\t-h, --help\t\t\tDisplay this help message" << std::endl;
}

/**
 * Initialize parameter
 * @param argc
 * @param argv
 */
void initParams(int argc, char *argv[]) {

    struct option longOptions[] = {
            {"output", required_argument, 0, 'o'},
            {"help",   no_argument,       0, 'h'},
            {0,        0,                 0, 0}
    };

    int optionIndex = 0;
    int c;
    while ((c = getopt_long(argc, argv, "ho:", longOptions, &optionIndex)) != -1) {
        switch (c) {
            case 'o':
                outputFile = optarg;
                break;
            case 'h':
            default:
                // Print by default
                break;
        }
    }
}

int main(int argc, char *argv[]) {

    // Initialize parameters
    initParams(argc, argv);

    // Store input files in a vector
    for(int i = optind; i < argc; ++i) {
        inputFiles.push_back(argv[i]);
    }

    // Check missing requirements
    if(outputFile.empty() || inputFiles.empty()) {
        printUsage();
        return ecc::EasyCC::ERR_CODE_PARAMS;
    }

    // Create easycc production mode
    std::shared_ptr<ecc::IEasyCC> easyccpro = std::make_shared<ecc::EasyCC>();

    // Create calculator
    Calculator calculator(easyccpro);

    // Compile files
    return calculator.compile(inputFiles, outputFile);
}


text:
package com.aperture_software.markdown4j;

import com.github.rjeschke.txtmark.LinkRef;

import java.util.List;

/**
 * Created by jhyun on 13. 12. 25.
 */
public class LinkRefTransformers {

    public static String apply(final List<LinkRefTransformer> linkRefTransformers, final String link) {
        String s = new String(link);
        for(LinkRefTransformer lrt : linkRefTransformers) {
            s = lrt.transform(s);
        }
        return s;
    }

}


text:
Anonymisierer: Schritt für Schritt Anleitung
============================================

1. [Ermittlung des Bedarfs an vorzunehmenden Verfremdungen](#step1)
2. [Erstellen der ersten Konfigurationsdatei](#step2)
3. [Analyse des Datenbankschemas starten](#analyzer)
4. [Analyeergebnis auswerten](#post-analysis)
5. [Datenbankschema in die Zieldatenbank einspielen](#createschema)
5. [Anonymisierung starten](#anonymize)
6. [Zieldatenbank transferieren](#movedestionationdb)

Schritt 1: Ermittlung des Bedarfs an vorzunehmenden Verfremdungen
-----------------------------------------------------------------

Bevor Sie den Anonymisierer benutzen können, müssen Sie zunächst festlegen,
welche Daten auf welche Art und Weise verfremdet (transformiert) werden sollen.
Als erstes sollten dafür die Relationen identifiziert werden, die überhaupt
herausgegeben und dafür anonymisiert werden sollen. Für deren Attribute müssen
dann geeignete Transformationsverfahren bestimmt werden. Die standardmäßig zur Verfügung gestellten Transformationsverfahren umfassen

1. das Leeren von Attributen (in allen Tupeln wird die betroffene Attribut auf
den gleichen Wert gesetzt -- vergleichbar mit Schwärzen von Spalten)
2. das Ersetzen jeder Attributausprägung durch ein eindeutiges Pseudonym
3. das zeichenweise Ersetzen durch Pseudonymzeichen (für zusammengesetzte
Attribute, bei denen jede Stelle z. B. in einem Code eine eigene Bedeutung
trägt)
4. das Löschen von Tupeln, die bestimmte Bedingungen erfüllen
5. das Löschen von Tupeln, sodass anschließend in einem Attribut einer Relation
von jeder Ausprägung gleich viele Exemplare übrig bleiben

Zusätzlich kann festgelegt werden, dass Tupel, die bestimmte Bedingungen erfüllen, auf keinen Fall gelöscht (aber dennoch verfremdet) werden sollen.

Sensible Informationen, wie zum Beispiel personenbezogene Daten, sollen in der
Regel dem Empfänger eines anonymisierten Datensatzes nicht zur Verfügung stehen.
Daher bietet sich für solche Attribute grundsätzlich Variante 1 (Leeren) an.
Allerdings lässt sich dabei anschließend nicht mehr feststellen, welche Tupel
sich in dem originalen Datensatz bei diesem Attribut voneinander unterschieden
haben. Wenn Sie zum Beispiel eine Relation mit von Kunden bestellten Artikeln
(Posten) haben und dort (vereinfacht angenommen) der Name als
Fremdschlüsselattribut in die Relation aller Kunden verwendet wurde, in der
Postenrelation der Name aus Datenschutzgründen aber geleert wird, lässt sich
anschließend nicht mehr ermitteln, ob zwei Posten zum selben Kunden gehörten
oder nicht. Je nachdem, zu welchem Zweck die anonymisierten Daten herausgegeben
werden, kann das erwünscht sein oder nicht. Falls der Verwendungszweck bedingt,
dass die Kundenzuordnung, wenn auch nicht namentlich, noch vorhanden sein muss,
bietet sich als Alternatives Transformationsverfahren die Variante 2
(Pseudonymisierung) an. Dabei wird beispielsweise Herr Müller zu "A" und Frau
Meier zu "C". Ihre Namen bleiben so verborgen, aber es kann noch unterschieden
werden, ob bestimmte Posten von "A" oder "C" gekauft wurden.

Manchmal werden in einem Attribut gleichzeitig mehrere Informationen
gespeichert (zusammengesetzte Attribute). Für den Fall, dass es sich bei dem
Attribut um ein Kodewort handelt, bei dem jedes einzelne Zeichen oder Gruppen
von Zeichen eine eigene Bedeutung trägt (zum Beispiel
"Produktnummer-Jahrgang-Seriennummer"), ist es womöglich von Vorteil, wenn
der Zusammenhang dieser Bedeutungen über alle Tupel hinweg erhalten bleibt (alle
Tupel, die vorher die gleiche Produktnummer im Kode aufwiesen, haben nach der
Anonymisierung immer noch untereinander gleiche Zeichen anstelle der
Produktnummer). Hierfür kann Variante 3 (zeichenweise Pseudonymisierung) benutzt
werden. Dabei wird jedem Zeichen ein neues Zeichen wie ein Pseudonym zugeordnet
(aus A wird beispielsweise C und aus U eine 7). So wird sichergestellt, dass
sich wiederholende Zeichenkombinationen auch im anonymisierten Datensatz als
andere sich wiederholende Zeichenkombinationen wiederzufinden sind (CC7 statt
AAU). Außerdem kann angegeben werden, dass nur ein Teil der Zeichenkette
verändert werden soll (Seriennummer wird transformiert, Produktnummer und
Jahrgang bleiben bestehen).

Bei jeder Pseudonymisierung oder Anonymisierung ist jedoch zu beachten, dass es
unter Umständen nicht ausreicht, nur ein Attribut zu leeren oder zu
pseudonymisieren. Oftmals lassen sich Attribute aus den anderen Attributen
innerhalb eines Tupels rekonstruieren, insbesondere, wenn weitere Datensätze
vorliegen, mit denen kreuzreferenziert werden kann (zum Beispiel hat [L.
Sweeney](#ref1) anhand von Volkszählungsdaten der USA aus dem Jahr 1990
ermittelt, dass 87% der US-Bürger nur anhand von fünfstelliger Postleitzahl,
Geschlecht und Geburtsdatum eindeutig identifiziert werden konnten). Daher
müssen bei jeder Relation zunächst einmal alle Attribute für die Anonymisierung
berücksichtigt werden, um eine wirkungsvolle Anonymisierung zu gewährleisten.

Sind einige Tupel besonders sensibel, weil sie zum Beispiel zu Prototypen
aus der Entwicklungsabteilung gehören, sollten diese Vermutlich mit Variante 4
komplett aus dem Datensatz entfernt werden. Von den gelöschten Tupeln abhängige
Tupel in anderen Relationen (z. B. über Fremdschlüssel oder weil in der
Anonymisiererkonfiguration so angegeben) werden ebenfalls gelöscht.

Manchmal sollen die Werteverteilungen innerhalb einer Relation geheim bleiben
(damit zum Beispiel nicht mehr ermittelt werden kann, welche Produkte sich
besonders gut verkauft haben). In diesem Fall können mit Variante 5 Tupel so
entfernt werden, dass am Ende für ein bestimmtes Attribut (Produktschlüssel) von
jeder Ausprägung gleich viele Tupel übrig bleiben (für jedes Produkt gibt es
dann beispielsweise gleich viele Posten).

Schritt 2: Erstellen der ersten Konfigurationsdatei
---------------------------------------------------

Ist man sich im ersten Schritt bewusst geworden, was mit den Daten passieren
soll, ist der nächste Schritt, dies in eine dem Anonymisierungsprogramm
verständliche Form zu bringen. Das Programm benötigt zwei Konfigurationsdateien.
Die erste ist eine Liste der überhaupt zu betrachtenden Relationen. Diese werden
in einer Textdatei aufgezählt, wobei der Name jeder Relation (Tabelle) auf einer
Zeile steht. Zum Beispiel:

    PRODUKTE
	POSTEN
	KUNDEN

Diese Textdatei nennen wir von nun an *Scope-Datei* (Scope (engl.) = Einflussbereich).

Die zweite Konfigurationsdatei enthält wesentlich mehr Informationen, denn sie
beschreibt, wie die einzelnen Attribute transformiert werden sollen, welche
davon miteinander zusammenhängen, woher die Daten überhaupt kommen und wohin sie
gespeichert werden sollen. Diese zweite Datei wird im folgenden schlicht die
*Konfigurationsdatei* genannt, da hierein die meiste Arbeit investiert werden
muss.

Für die ersten Zeilen können zu Beginn folgende Zeilen kopiert werden:

    jdbc:db2://dbserver:port/OriginalDB Benutzername Passwort
    jdbc:db2://dbserver:port/ZielDB Benutzername Passwort
    jdbc:db2://dbserver:port/TransformationsDB Benutzername Passwort
    # Schemaname und Batch-Insert-Größe
    DBSCHEMA 10000

    - D: de.hpi.bp2013n1.anonymizer.SetDefaultStrategy
    - P: de.hpi.bp2013n1.anonymizer.PseudonymizeStrategy
    - C: de.hpi.bp2013n1.anonymizer.CharacterStrategy
    - U: de.hpi.bp2013n1.anonymizer.UniformDistributionStrategy
	- DeleteWhere: de.hpi.bp2013n1.anonymizer.DeleteRowStrategy
    - RetainWhere: de.hpi.bp2013n1.anonymizer.RetainRowStrategy

Zeilen, die mit einer Raute (#) beginnen, sind Kommentarzeilen und werden vom
Programm ignoriert. Sie denen lediglich dem besseren Verständnis für den Leser
der Datei.

In den ersten drei Zeilen wird definiert, wie mit den an der Anonymisierung
beteiligten Datenbanken verbunden werden kann. Die erste Zeile enthält die
JDBC-URL für eine Verbindung zur Datenbank, die die originalen Daten enthält,
gefolgt vom für die Verbindung zu benutzenden Benutzernamen und dessen Passwort.
Der Datenbankmanagementsystem-(DBMS)-Benutzer, der hier angegeben wird, muss
Leseberechtigungen für die zu anonymisierenden Daten und die Metadaten
(Fremdschlüssel etc.) für die Relationen haben. Wie die JDBC-URL aufgebaut ist,
hängt vom verwendeten DBMS ab. Die obigen URLs sind an die von IBM DB2
angelehnt. Sie enthalten vor allem den Hostnamen oder die IP-Adresse des
Datenbankservers, auf welchem Port dort mit der Datenbank verbunden werden kann
und den Namen der Datenbank auf dem Server. Bei Dateigestützten DBMS kann die
URL zum Beispiel den Pfad zur Datenbankdatei enthalten. Konsultieren Sie hierfür
die Dokumentation ihres Datenbanksystems und wie man dazu mittels JDBC
Verbindungen aufbauen kann.

Die zweite Zeile enthält die gleichen Informationen, aber für die Datenbank, in
der die anonynmisierten Daten gespeichert werden sollen. Hier muss der
DBMS-Benutzer Schreibrechte haben. Das Anonymisierungsprogramm geht davon aus,
dass bereits alle Tabellen dort angelegt wurden, daher muss dies
[später](#createschema) als vorbereitende Maßnahme geschehen. Die dritte Zeile
gibt eine Datenbank an, die das Anonymisierungsprogramm benutzen kann, um
beispielsweise die erzeugten Pseudonyme zu hinterlegen. Hier muss der
DBMS-Benutzer Schreib- und Leserechte haben und auch neue Relationen anlegen
können.

Es muss nicht für jede der drei Datenbanken das gleiche DMBS verwendet werden.
Im Gegenteil ist es von Vorteil, wenn die Zieldatenbank von den anderen beiden
getrennt ist. Da sich mithilfe der Transformationsdatenbank die Anonymisierung
teilweise rückgängig machen lässt, muss diese genauso wie die Originaldatenbank
unter Verschluss gehalten werden (falls man sie nach der Anonymisierung nicht
gleich löschen möchte).

Unter den drei Zeilen mit den drei Datenbanken folgt eine Zeile, in der das
Schema, in dem die zu anonymisierenden Relationen definiert sind, aufgeführt
wird, sowie die Anzahl der Zeilen, die beim Einfügen in die Zieldatenbank
jeweils gleichzeitig dorthin geschickt werden. Höhere Zahlen führen in der Regel
zu höherer Geschwindigkeit, allerdings unterstützen nicht alle DBMS beliebig
große Werte (bei DB2 kann beispielsweise das Transaktionslog volllaufen, wenn
die Zahl zu groß gewählt wird).

Die mit einem Minus beginnenden Zeilen definieren, welche
Transformationsverfahren der Anonymisierer verwenden soll. Vor dem Doppelpunkt
steht jeweils ein frei wählbares Zeichen oder Wort, mit dem das Verfahren im
Folgenden in der Konfigurationsdatei benannt wird. Hierbei darf es keine
Doppelungen geben. Hinter dem Doppelpunkt steht jeweils der vollqualifizierte
Name der Java-Klasse, in der das Verfahren implementiert ist. Die oben genannten
sind die standardmäßig mitgelieferten Verfahren. Die SetDefaultStrategy leert
Attribute (setzt ein Attribut für jedes Tupel auf den gleichen Wert),
PseudonymizeStrategy ersetzt Werte durch Pseudonyme, CharacterStrategy tut das
zeichenweise, UniformDistributionStrategy löscht Tupel, um eine Gleichverteilung
für ein Attribut zu erreichen, DeleteRowStrategy löscht Tupel, die eine
Bedingung erfüllen, und RetainRowStrategy erzwingt, dass solche behalten werden,
die eine Bedingung erfüllen.

Anschließend werden die Anonymisierungsregeln in folgender Form notiert:

    Relation.Attribut    Verfahren   (zusätzliche Angaben)
	    Relation.AbhängigesAttribut
		AndereRelation.AbhängigesAttribut

*Relation.Attribut* ist dabei das Attribut (oder für manche Verfahren auch nur
die Relation), auf das das durch *Verfahren* benannte Transformationsverfahren
angewendet werden soll. Bei *Verfahren* muss eines der Wörter benutzt werden,
die bei den zuvor erläuterten mit Minus beginnenden Zeilen vor dem Doppelpunkt
standen. Die meisten Verfahren benötigen oder akzeptieren optional zusätzliche
Angaben, um die Transformation zu beeinflussen. Unter der ersten Zeile einer
solchen Regel können nun eingerückt weitere Attribute in derselben oder anderen
Relationen aufgezählt werden, die von *Relation.Attribut* abhängig sind und
daher auf die gleiche Art und Weise transformiert werden müssen (das heißt zum
Beispiel unter Verwendung der gleichen Pseudonyme). Das ist vor allem bei
Fremdschlüsseln wichtig. Gibt es keine abhängigen Attribute, kann einfach die
nächste Transformationsregel uneingerückt darunter notiert werden.

Wenn die Abhängigkeiten im DBMS als Fremdschlüssel definiert sind oder die Namen
der abhängigen Attribute den übergeordneten Attributnamen enthalten, kann das
Program die Abhängigkeiten auch selbst [im nächsten Schritt](#analyzer)
ermitteln.

Um auf das vorangegangene Beispiel mit den Produkten, Kunden und Posten
zurückzukommen, könnte eine mögliche Konfigurationsdatei wie folgt aussehen:

    jdbc:db2://dbserver:port/OriginalDB Benutzername Passwort
    jdbc:db2://dbserver:port/ZielDB Benutzername Passwort
    jdbc:db2://dbserver:port/TransformationsDB Benutzername Passwort
    DBSCHEMA 10000

    - D: de.hpi.bp2013n1.anonymizer.SetDefaultStrategy
    - P: de.hpi.bp2013n1.anonymizer.PseudonymizeStrategy
    - U: de.hpi.bp2013n1.anonymizer.UniformDistributionStrategy
	- DeleteWhere: de.hpi.bp2013n1.anonymizer.DeleteRowStrategy
    - RetainWhere: de.hpi.bp2013n1.anonymizer.RetainRowStrategy

    ARTIKEL.NUMMER         P
        POSTEN.ARTIKELNUMMER
	ARTIKEL                RetainWhere  NUMMER < 1000
	ARTIKEL                DeleteWhere  PREIS > 100
	POSTEN.ARTIKELNUMMER   U
    KUNDEN.NAME            P  Kunde
        POSTEN.KUNDENNAME
	ARTIKEL.EINSTELLDATUM  D  1990-01-01

Diese Konfiguration würde bewirken, dass bei der Anonymisierung...

1. alle Artikel neu durchnummeriert werden
und die in der POSTEN-Relation referenzierenden Artikelnummern dementsprechend
angepasst werden
2. alle Artikel und davon (über die Nummer) abhängige Posten mit einem
Preis von über 100 gelöscht werden, außer wenn ihre Artikelnummer kleiner als
1000 ist
3. Posten so gelöscht werden, dass es am Ende zu jedem Artikel gleich viele
Posten gibt
4. Kundennamen durch Pseudonyme ersetzt werden (sowohl in der KUNDEN-Relation
als auch in der POSTEN-Relation), wobei jedes Pseudonym mit "Kunde" beginnt
(gefolgt von einer zufälligen Zeichenfolge)
5. das Einstelldatum aller Artikel auf den 1.1.1990 gesetzt wird

Dabei gilt natürlich, dass die Originaldatenbank nicht verändert wird, sondern
dass die Veränderungen den Unterschied zwischen Originaldatenbank und
Zieldatenbank beschreiben.

Das Einrücken der Verfahrenskürzel (P, U usw.), sodass diese alle untereinander
stehen, ist nicht notwendig, wird aber der Übersichtlichkeit halber empfohlen.

In diesem Beispiel haben Sie bereits einige zusätzliche Angaben für
Transformationsregeln und, was sie bewirken, gesehen. Hier eine komplette Liste
der Angaben, die für die standardmäßig bereitgestellten Verfahren gemacht werden
können:

**SetDefaultStrategy**: es kann angegeben werden, auf welchen Wert das Attribut
gesetzt wird

**PseudonymizeStrategy**: es kann ein Präfix angegeben werden, mit dem alle
Pseudonyme beginnen (darf nicht zu lang für das Attribut sein)

**CharacterStrategy**: es muss ein Ersetzungsmuster angegeben werden. Die Länge
des Musters muss mit der Länge des Attributs übereinstimmen. Im Muster steht `K`
dafür, eine Stelle nicht zu ersetzen, und `P` dafür, eine Stelle durch
Pseudonymzeichen zu ersetzen. Ein Muster von `PPPKKKP` sorgt bei einem
siebenstelligen Attribut also dafür, dass die ersten drei und die letzte Stelle
ersetzt werden, während die verbliebenen drei Stellen so bleiben, wie sie sind.

**DeleteRowStrategy**: es muss eine Löschbedingung in Form einer
SQL-WHERE-Klausel (ohne WHERE) angegeben werden.

**RetainRowStrategy**: es muss eine Bedingung für zu behaltende Tupel in Form
einer SQL-WHERE-Klausel (ohne WHERE) angegeben werden.

**UniformDistributionStrategy**: es können zwei Sachverhalte kodiert werden:

1. Eine Projektion des Attributwerts, die angewendet wird, bevor die
Ausprägungen gezählt werden. Durch die Angabe von `SUBSTR(..., 1, 1)` (das
DBMS muss dafür eine SUBSTR-Funktion unterstützen) könnte zum Beispiel
erreicht werden, dass nach Anwendung des Verfahrens für jeden ersten
vorkommenden Buchstaben im Attribut gleich viele Tupel vorliegen.
2. Eine Mindestmenge an Tupeln kann spezifiziert werden, die eine Ausprägung
erreichen muss, damit sie nicht komplett gelöscht wird. Wenn eine Ausprägung
beispielsweise nur einmal vorkommt, würde für jede Ausprägung nur noch ein
Tupel übrig bleiben. Durch eine Angabe von `require at least 10` kann
erreicht werden, dass alle Tupel mit Ausprägungen, die weniger oft als zehn
mal vorkommen, gelöscht werden, dafür aber für jede andere Ausprägung
mindestens zehn Tupel erhalten bleiben. Durch `require at least 20%` werden
alle Ausprägungen verworfen, die weniger als 20% Vorkommen im Vergleich zur
*häufigsten* Ausprägung des Attributs haben. Es wird also sichergestellt,
dass mindestens 20% der Tupel mit der häufigsten Ausprägung erhalten bleiben
(und ebenso viele mit anderen Ausprägungen, bis auf jene mit den zu seltenen
Ausprägungen).

Beide Angaben können durch ein Semikolon getrennt kombiniert werden. Zum
Beispiel stellt `SUBSTR(..., 1, 3); require at least 20` sicher, dass für jede
Kombination der ersten drei Zeichen des Attributs mindestens 20 Tupel übrig
bleiben. Tupel mit Kombinationen, die weniger als 20 Mal vorkommen, werden
gelöscht.

Schritt 3: Analyse des Datenbankschemas starten
-----------------------------------------------

Nachdem mit der ersten Konfigurationsdatei grundsätzlich definiert wurde, welche
Daten wie anonymisiert werden sollen, sollten als nächstes alle Abhängigkeiten
zu den zu transformierenden Attributen und Tabellen aufgedeckt werden. Fehlen
einige davon in der Konfiguration kann es beim Übertragen der Daten in die
Zieldatenbank zu Constraint-Verletzungen bspw. durch nicht beachtete
Fremdschlüsselbeziehungen kommen.

Um weitere Abhängigkeiten automatisch aufzudecken, enthält das Programm einen
Analysierer, der die Metadaten der Originaldatenbank nach Fremschlüsseln und
ähnlich lautenden Attributen durchsucht. Dabei wird eine ergänzte
Konfigurationsdatei erzeugt. Dieser Analysierer wird folgendermaßen
aufgerufen:

    $ java -cp Analyzer.jar:jdbcdriver.jar de.hpi.bp2013n1.anonymizer.analyzer.Main Konfiguration_vorher.txt scope.txt Konfiguration_hinterher.txt

*jdbcdriver.jar* ist dabei die Java-Bibliothek, die ggf. benötigt wird, damit
ihr JDBC-Treiber für die Datenbankverbindungen geladen werden kann. Bei DB2 ist
das in der Regel eine Datei namens db2jcc.jar oder db2jcc4.jar.
*Konfiguration_vorher.txt* ist die Konfigurationsdatei, die sie im [vorigen
Schritt](#step2) erstellt haben, während *scope.txt* die Scope-Datei ist. Bei
*Konfiguration_hinterher.txt* können Sie durch einen beliebigen Dateinamen oder
Pfad angeben, wo die neue, ergänzte Konfigurationsdatei erstellt werden soll.
Existierende Dateien werden dabei überschrieben!

Neben dem Aufdecken zusätzlicher Abhängigkeiten wird die Konfigurationsdatei bei
der Analyse auch auf ihre Gültigkeit überprüft. Dazu gehört auch, dass die
einzelnen Transformationsverfahren überprüfen, ob die zusätzlichen Angaben zu
jeder Regel den Voraussetzungen des jeweiligen Verfahrens entsprechen.

Schritt 4: Auswertung des Analyseergebnisses
--------------------------------------------

Durch den Analysierer wird eine neue Konfigurationsdatei ausgegeben, die ggf.
mehr Zeilen enthält, als die, die sie im zweiten Schritt erstellt haben. Für das
oben genannte Beispiel mit Produkten, Kunden und Posten könnte das Ergebnis zum
Beispiel so aussehen:

    jdbc:db2://dbserver:port/OriginalDB Benutzername Passwort
    jdbc:db2://dbserver:port/ZielDB Benutzername Passwort
    jdbc:db2://dbserver:port/TransformationsDB Benutzername Passwort
    DBSCHEMA 10000

    - D: de.hpi.bp2013n1.anonymizer.SetDefaultStrategy
    - P: de.hpi.bp2013n1.anonymizer.PseudonymizeStrategy
    - U: de.hpi.bp2013n1.anonymizer.UniformDistributionStrategy
	- DeleteWhere: de.hpi.bp2013n1.anonymizer.DeleteRowStrategy

    ARTIKEL.NUMMER         P
        POSTEN.ARTIKELNUMMER
		LAGER.ARTIKELNUMMER
	ARTIKEL                RetainWhere  NUMMER < 1000
	ARTIKEL                DeleteWhere  PREIS > 100
	POSTEN.ARTIKELNUMMER   U
    KUNDEN.NAME            P  Kunde
        POSTEN.KUNDENNAME
		#ARTIKEL.NAME
        #KUNDENKARTEN.KUNDENNAME
	ARTIKEL.EINSTELLDATUM  D  1990-01-01
	    #MITARBEITER.EINSTELLDATUM

Hier wurden vier Abhängigkeiten ergänzt:

1. eine im DBMS vorhandene Fremdschlüsselbeziehung von LAGER.ARTIKELNUMMER zu
ARTIKEL.NUMMER
2. ein zu KUNDEN.NAME ähnlich lautendes Attribut ARTIKEL.NAME
3. ein zu KUNDEN.NAME ähnlich lautendes Attribut KUNDENKARTEN.KUNDENNAME
4. ein zu ARTIKEL.EINSTELLDATUM ähnlich bzw. gleichlautendes Attribut
MITARBEITER.EINSTELLDATUM

Bei den Nummern 2 und 4 handelt es sich vermutlich nicht um Abhängigkeiten, da die
Attribute nur gleich heißen, die Artikelbezeichnung aber nicht mit einem
Kundennamen zusammenhängen dürfte, genausowenig wie das Einstelldatum eines
Mitarbeiters von dem eines Artikels abhängen sollte. Wegen solcher
Unsicherheiten sind alle Vorschläge, die das Programm unterbreitet, die es nicht
auf Fakten aus dem DBMS wie Fremdschlüssel zurückführen kann, standardmäßig
auskommentiert (daher die Raute). Der Vorschlag mit der Nummern 3 könnte
jedoch sehr wohl eine gültige Beziehungen sein, obwohl dafür kein Fremdschlüssel
im DBMS angelegt war. Um diese bei der folgenden Anonymisierung zu beachten,
sollte die Raute entfernt werden, damit die Zeile nicht mehr auskommentiert
ist.

Schritt 5: Datenbankschema in die Zieldatenbank einspielen
----------------------------------------------------------

Die Zieldatenbank sollte vor der Anonymisierung vom Aufbau her der
Originaldatenbank entsprechen. Lediglich Tupel sollte sie noch keine enthalten.
Um das Schema zu übertragen nutzen Sie am besten die Werkzeuge, die Ihnen Ihr
DBMS zur Verfügung stellt. Das Anonymisierungsprogramm enthält keine derartige
Funktionalität.

Schritt 6: Anonymisierung starten
---------------------------------

Nach den vielen vorbereitenden Schritten kann nun die Anonymisierung gestartet
werden. Dazu sollte folgendes auf der Kommandozeile ausgeführt werden:

    $ java -cp Anonymizer.jar:jdbcdriver.jar de.hpi.bp2013n1.anonymizer.Anonymizer Konfiguration.txt scope.txt Protokolldatei.log

*jdbcdriver.jar* ist hier wieder der bereits in der [Analyse](#analyzer)
erwähnte JDBC-Treiber für die verwendeten DBMS. *Konfiguration.txt* ist die
finale Version der Konfigurationsdatei, die in [Schritt 4](#post-analysis)
entstanden ist. *scope.txt* ist wieder die Scope-Datei. Bei *Protokolldatei.log*
muss ein Dateiname oder Pfad angegeben werden, wohin das Programm Fehler, die
bei der Anonymisierung auftreten können, speichern wird. Diese Logdatei kann
unter Umständen Informationen enthalten, die dem Empfänger des anonymisierten
Datensatzes nicht bekannt werden sollen. Daher sollte diese Logdatei genauso wie
die Transformationsdatenbank nicht herausgegeben werden.

Nach diesem Schritt sollten, sofern keine gravierenden Fehler aufgetreten sind,
in der Zieldatenbank die anonymisierten Tupel vorliegen.

Schritt 7: Zieldatenbank transferieren
--------------------------------------

Falls die in der Konfigurationsdatei angegebene Zieldatenbankinstanz noch nicht
beim Empfänger der anonymisierten Daten liegt, muss diese noch in geeigneter
Form exportiert und dem Empfänger überreicht werden. Bitte benutzen Sie hierzu
wieder die Werkzeuge, die Ihr DBMS Ihnen zur Verfügung stellt, da das
Anonymisierungsprogramm keine Funktionalität für diesen Schritt bereitstellt.

Referenzen
----------
-
  L. Sweeney, *Uniqueness of Simple Demographics in the U.S. Population*,
  LIDAPWP4.
  Carnegie Mellon University, Laboratory for International Data Privacy,
  Pittsburgh, PA: 2000.