text:
package org.apache.storm.utils;

import org.apache.storm.Config;
import org.apache.thrift.transport.TTransportException;
import org.junit.Assert;
import org.junit.Test;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;

public class UtilsTest {

    @Test
    public void isZkAuthenticationConfiguredTopologyTest() {
        Assert.assertFalse(
                "Returns null if given null config",
                Utils.isZkAuthenticationConfiguredTopology(null));

        Assert.assertFalse(
                "Returns false if scheme key is missing",
                Utils.isZkAuthenticationConfiguredTopology(emptyMockMap()));

        Assert.assertFalse(
                "Returns false if scheme value is null",
                Utils.isZkAuthenticationConfiguredTopology(topologyMockMap(null)));

        Assert.assertTrue(
                "Returns true if scheme value is string",
                Utils.isZkAuthenticationConfiguredTopology(topologyMockMap("foobar")));
    }

    private Map topologyMockMap(String value) {
        return mockMap(Config.STORM_ZOOKEEPER_TOPOLOGY_AUTH_SCHEME, value);
    }

    private Map mockMap(String key, String value) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put(key, value);
        return map;
    }

    private Map serverMockMap(String value) {
        return mockMap(Config.STORM_ZOOKEEPER_AUTH_SCHEME, value);
    }

    private Map emptyMockMap() {
        return new HashMap<String, Object>();
    }

    private void doParseJvmHeapMemByChildOptsTest(String message, String opt, double expected) {
        doParseJvmHeapMemByChildOptsTest(message, Arrays.asList(opt), expected);
    }

    private void doParseJvmHeapMemByChildOptsTest(String message, List<String> opts, double expected) {
        Assert.assertEquals(
                message,
                Utils.parseJvmHeapMemByChildOpts(opts, 123.0).doubleValue(), expected, 0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestK() {
        doParseJvmHeapMemByChildOptsTest("Xmx1024k results in 1 MB", "Xmx1024k", 1.0);
        doParseJvmHeapMemByChildOptsTest("Xmx1024K results in 1 MB", "Xmx1024K", 1.0);
        doParseJvmHeapMemByChildOptsTest("-Xmx1024k results in 1 MB", "-Xmx1024k", 1.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestM() {
        doParseJvmHeapMemByChildOptsTest("Xmx100M results in 100 MB", "Xmx100m", 100.0);
        doParseJvmHeapMemByChildOptsTest("Xmx100m results in 100 MB", "Xmx100M", 100.0);
        doParseJvmHeapMemByChildOptsTest("-Xmx100M results in 100 MB", "-Xmx100m", 100.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestG() {
        doParseJvmHeapMemByChildOptsTest("Xmx1g results in 1024 MB", "Xmx1g", 1024.0);
        doParseJvmHeapMemByChildOptsTest("Xmx1G results in 1024 MB", "Xmx1G", 1024.0);
        doParseJvmHeapMemByChildOptsTest("-Xmx1g results in 1024 MB", "-Xmx1g", 1024.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestNoMatch() {
        doParseJvmHeapMemByChildOptsTest("Unmatched unit results in default", "Xmx1t", 123.0);
        doParseJvmHeapMemByChildOptsTest("Unmatched option results in default", "Xms1g", 123.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestNulls() {
        doParseJvmHeapMemByChildOptsTest("Null value results in default", (String) null, 123.0);
        doParseJvmHeapMemByChildOptsTest("Null list results in default", (List<String>) null, 123.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestExtraChars() {
        doParseJvmHeapMemByChildOptsTest("Leading characters are ignored", "---Xmx1g", 1024.0);
        doParseJvmHeapMemByChildOptsTest("Trailing characters are ignored", "Xmx1ggggg", 1024.0);
    }

    @Test
    public void parseJvmHeapMemByChildOptsTestFirstMatch() {
        doParseJvmHeapMemByChildOptsTest("First valid match is used",
                Arrays.asList(null, "Xmx1t", "Xmx1g", "Xms1024k Xmx1024k", "Xmx100m"),
                1024.0);
    }

    public void getConfiguredClientThrowsRuntimeExceptionOnBadArgsTest () throws TTransportException {
        Map<String, Object> config = ConfigUtils.readStormConfig();
        config.put(Config.STORM_NIMBUS_RETRY_TIMES, 0);

        try {
            new NimbusClient(config, "", 65535);
            Assert.fail("Expected exception to be thrown");
        } catch (RuntimeException e){
            Assert.assertTrue(
                    "Cause is not TTransportException " + e,
                    Utils.exceptionCauseIsInstanceOf(TTransportException.class, e));
        }
    }

    @Test
    public void isZkAuthenticationConfiguredStormServerTest() {
        Assert.assertFalse(
                "Returns false if given null config",
                Utils.isZkAuthenticationConfiguredStormServer(null));

        Assert.assertFalse(
                "Returns false if scheme key is missing",
                Utils.isZkAuthenticationConfiguredStormServer(emptyMockMap()));

        Assert.assertFalse(
                "Returns false if scheme value is null",
                Utils.isZkAuthenticationConfiguredStormServer(serverMockMap(null)));

        Assert.assertTrue(
                "Returns true if scheme value is string",
                Utils.isZkAuthenticationConfiguredStormServer(serverMockMap("foobar")));
    }

    @Test
    public void isZkAuthenticationConfiguredStormServerWithPropertyTest() {
        String key = "java.security.auth.login.config";
        String oldValue = System.getProperty(key);
        try {
            System.setProperty("java.security.auth.login.config", "anything");
            Assert.assertTrue(Utils.isZkAuthenticationConfiguredStormServer(emptyMockMap()));
        } finally {
            // reset property
            if (oldValue == null) {
                System.clearProperty(key);
            } else {
                System.setProperty(key, oldValue);
            }
        }
    }
}


text:
package de.uniulm.omi.cloudiator.visor.telnet;

import com.google.inject.Inject;
import de.uniulm.omi.cloudiator.visor.monitoring.Metric;
import de.uniulm.omi.cloudiator.visor.reporting.QueuedReporting;
import de.uniulm.omi.cloudiator.visor.reporting.ReportingInterface;

import java.net.Socket;

/**
 * Created by daniel on 16.12.14.
 */
public class SocketWorkerFactory implements SocketWorkerFactoryInterface {

    private final ReportingInterface<Metric> metricReporting;
    private final RequestParsingInterface<String, Metric> requestParser;

    @Inject public SocketWorkerFactory(@QueuedReporting ReportingInterface<Metric> metricReporting,
        RequestParsingInterface<String, Metric> requestParser) {
        this.metricReporting = metricReporting;
        this.requestParser = requestParser;
    }

    @Override public SocketWorker create(Socket socket) {
        return new SocketWorker(socket, metricReporting, requestParser);
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
        <title>Science Papers Scores</title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">

        <link rel="stylesheet" href="template/css/bootstrap.min.css">

        <link rel="stylesheet" href="template/css/bootstrap-theme.min.css">
        <link rel="stylesheet" href="template/css/jquery.dataTables.min.css">
        <link rel="stylesheet" href="template/css/dataTables.bootstrap.css">
        <link rel="stylesheet" href="//cdn.datatables.net/tabletools/2.2.2/css/dataTables.tableTools.css">
        <link rel="stylesheet" href="template/css/main.css">

          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
            Toggle navigation

          </button>
          Science Papers Scores

                    Id
                    Author
                    Papers

                    Id
                    Author
                    Papers

            GitHub |  MIT Licence

                <button type="button" class="close" data-dismiss="modal">×Close</button>

Details:

                <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>


text:
Run with:
```bash
node eg/slider-servo-control.js
```

```javascript
var five = require("johnny-five"),
  board, slider, servo, scalingRange;

board = new five.Board();

board.on("ready", function() {

  scalingRange = [0, 170];

  slider = new five.Sensor({
    pin: "A0",
    freq: 50
  });

  servo = new five.Servo({
    pin: 9,
    range: scalingRange
  });

  // The slider's value will be scaled to match the servo's movement range

  slider.scale(scalingRange).on("slide", function(err, value) {

    servo.to(Math.floor(this.value));

  });
});

```

## Breadboard/Illustration

![docs/breadboard/slider-servo-control.png](breadboard/slider-servo-control.png)

## License
Copyright (c) 2012-2013 Rick Waldron <waldron.rick@gmail.com>
Licensed under the MIT license.
Copyright (c) 2014 The Johnny-Five Contributors
Licensed under the MIT license.


text:
require "rss-testcase"

require "rss/maker"

module RSS
  class TestSetupMaker09 < TestCase

    def test_setup_maker_channel
      title = "fugafuga"
      link = "http://hoge.com"
      description = "fugafugafugafuga"
      language = "ja"
      copyright = "foo"
      managingEditor = "bar"
      webMaster = "web master"
      rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
      docs = "http://foo.com/doc"
      skipDays = [
        "Sunday",
        "Monday",
      ]
      skipHours = [
        "0",
        "13",
      ]
      pubDate = Time.now
      lastBuildDate = Time.now

      rss = RSS::Maker.make("0.91") do |maker|
        maker.channel.title = title
        maker.channel.link = link
        maker.channel.description = description
        maker.channel.language = language
        maker.channel.copyright = copyright
        maker.channel.managingEditor = managingEditor
        maker.channel.webMaster = webMaster
        maker.channel.rating = rating
        maker.channel.docs = docs
        maker.channel.pubDate = pubDate
        maker.channel.lastBuildDate = lastBuildDate

        skipDays.each do |day|
          maker.channel.skipDays.new_day do |new_day|
            new_day.content = day
          end
        end
        skipHours.each do |hour|
          maker.channel.skipHours.new_hour do |new_hour|
            new_hour.content = hour
          end
        end

        setup_dummy_image(maker)
      end

      assert_not_set_error("maker.image", %w(title url)) do
        RSS::Maker.make("0.91") do |maker|
          rss.channel.setup_maker(maker)
        end
      end

      new_rss = RSS::Maker.make("0.91") do |maker|
        rss.channel.setup_maker(maker)
        setup_dummy_image(maker)
      end
      channel = new_rss.channel

      assert_equal(title, channel.title)
      assert_equal(link, channel.link)
      assert_equal(description, channel.description)
      assert_equal(language, channel.language)
      assert_equal(copyright, channel.copyright)
      assert_equal(managingEditor, channel.managingEditor)
      assert_equal(webMaster, channel.webMaster)
      assert_equal(rating, channel.rating)
      assert_equal(docs, channel.docs)
      assert_equal(pubDate, channel.pubDate)
      assert_equal(lastBuildDate, channel.lastBuildDate)

      skipDays.each_with_index do |day, i|
        assert_equal(day, channel.skipDays.days[i].content)
      end
      skipHours.each_with_index do |hour, i|
        assert_equal(hour.to_i, channel.skipHours.hours[i].content)
      end

      assert(channel.items.empty?)
      assert_nil(channel.textInput)
    end

    def test_setup_maker_image
      title = "fugafuga"
      link = "http://hoge.com"
      url = "http://hoge.com/hoge.png"
      width = "144"
      height = "400"
      description = "an image"

      rss = RSS::Maker.make("0.91") do |maker|
        setup_dummy_channel(maker)
        maker.channel.link = link

        maker.image.title = title
        maker.image.url = url
        maker.image.width = width
        maker.image.height = height
        maker.image.description = description
      end

      new_rss = RSS::Maker.make("0.91") do |maker|
        rss.channel.setup_maker(maker)
        rss.image.setup_maker(maker)
      end

      image = new_rss.image
      assert_equal(title, image.title)
      assert_equal(link, image.link)
      assert_equal(url, image.url)
      assert_equal(width.to_i, image.width)
      assert_equal(height.to_i, image.height)
      assert_equal(description, image.description)
    end

    def test_setup_maker_textinput
      title = "fugafuga"
      description = "text hoge fuga"
      name = "hoge"
      link = "http://hoge.com"

      rss = RSS::Maker.make("0.91") do |maker|
        setup_dummy_channel(maker)
        setup_dummy_image(maker)

        maker.textinput.title = title
        maker.textinput.description = description
        maker.textinput.name = name
        maker.textinput.link = link
      end

      new_rss = RSS::Maker.make("0.91") do |maker|
        rss.channel.setup_maker(maker)
        rss.image.setup_maker(maker)
        rss.textinput.setup_maker(maker)
      end

      textInput = new_rss.channel.textInput
      assert_equal(title, textInput.title)
      assert_equal(description, textInput.description)
      assert_equal(name, textInput.name)
      assert_equal(link, textInput.link)
    end

    def test_setup_maker_items(for_backward_compatibility=false)
      title = "TITLE"
      link = "http://hoge.com/"
      description = "text hoge fuga"

      item_size = 5

      rss = RSS::Maker.make("0.91") do |maker|
        setup_dummy_channel(maker)

        item_size.times do |i|
          maker.items.new_item do |item|
            item.title = "#{title}#{i}"
            item.link = "#{link}#{i}"
            item.description = "#{description}#{i}"
          end
        end

        setup_dummy_image(maker)
      end

      new_rss = RSS::Maker.make("0.91") do |maker|
        rss.channel.setup_maker(maker)

        rss.items.each do |item|
          if for_backward_compatibility
            item.setup_maker(maker)
          else
            item.setup_maker(maker.items)
          end
        end

        rss.image.setup_maker(maker)
      end

      assert_equal(item_size, new_rss.items.size)
      new_rss.items.each_with_index do |item, i|
        assert_equal("#{title}#{i}", item.title)
        assert_equal("#{link}#{i}", item.link)
        assert_equal("#{description}#{i}", item.description)
      end
    end

    def test_setup_maker_items_backward_compatibility
      test_setup_maker_items(true)
    end

    def test_setup_maker
      encoding = "EUC-JP"
      standalone = true

      href = 'a.xsl'
      type = 'text/xsl'
      title = 'sample'
      media = 'printer'
      charset = 'UTF-8'
      alternate = 'yes'

      rss = RSS::Maker.make("0.91") do |maker|
        maker.encoding = encoding
        maker.standalone = standalone

        maker.xml_stylesheets.new_xml_stylesheet do |xss|
          xss.href = href
          xss.type = type
          xss.title = title
          xss.media = media
          xss.charset = charset
          xss.alternate = alternate
        end

        setup_dummy_channel(maker)
        setup_dummy_image(maker)
      end

      new_rss = RSS::Maker.make("0.91") do |maker|
        rss.setup_maker(maker)
      end

      assert_equal("0.91", new_rss.rss_version)
      assert_equal(encoding, new_rss.encoding)
      assert_equal(standalone, new_rss.standalone)

      xss = rss.xml_stylesheets.first
      assert_equal(1, rss.xml_stylesheets.size)
      assert_equal(href, xss.href)
      assert_equal(type, xss.type)
      assert_equal(title, xss.title)
      assert_equal(media, xss.media)
      assert_equal(charset, xss.charset)
      assert_equal(alternate, xss.alternate)
    end
  end
end


text:
use shared::guiddef::{GUID};
use shared::lmcons::{NET_API_STATUS, ENCRYPTED_PWLEN, PARMNUM_BASE_INFOLEVEL, PWLEN};
use shared::minwindef::{DWORD, ULONG, FILETIME, LPBYTE, PBYTE, BYTE, BOOL};
use um::winnt::{BOOLEAN, LPWSTR, PSID, SID_NAME_USE};

STRUCT!{struct USER_INFO_0 {
    usri0_name: LPWSTR,
}}
pub type PUSER_INFO_0 = *mut USER_INFO_0;
pub type LPUSER_INFO_0 = *mut USER_INFO_0;
STRUCT!{struct USER_INFO_1 {
    usri1_name: LPWSTR,
    usri1_password: LPWSTR,
    usri1_password_age: DWORD,
    usri1_priv: DWORD,
    usri1_home_dir: LPWSTR,
    usri1_comment: LPWSTR,
    usri1_flags: DWORD,
    usri1_script_path: LPWSTR,
}}
pub type PUSER_INFO_1 = *mut USER_INFO_1;
pub type LPUSER_INFO_1 = *mut USER_INFO_1;
STRUCT!{struct USER_INFO_2 {
    usri2_name: LPWSTR,
    usri2_password: LPWSTR,
    usri2_password_age: DWORD,
    usri2_priv: DWORD,
    usri2_home_dir: LPWSTR,
    usri2_comment: LPWSTR,
    usri2_flags: DWORD,
    usri2_script_path: LPWSTR,
    usri2_auth_flags: DWORD,
    usri2_full_name: LPWSTR,
    usri2_usr_comment: LPWSTR,
    usri2_parms: LPWSTR,
    usri2_workstations: LPWSTR,
    usri2_last_logon: DWORD,
    usri2_last_logoff: DWORD,
    usri2_acct_expires: DWORD,
    usri2_max_storage: DWORD,
    usri2_units_per_week: DWORD,
    usri2_logon_hours: PBYTE,
    usri2_bad_pw_count: DWORD,
    usri2_num_logons: DWORD,
    usri2_logon_server: LPWSTR,
    usri2_country_code: DWORD,
    usri2_code_page: DWORD,
}}
pub type PUSER_INFO_2 = *mut USER_INFO_2;
pub type LPUSER_INFO_2 = *mut USER_INFO_2;
STRUCT!{struct USER_INFO_3 {
    usri3_name: LPWSTR,
    usri3_password: LPWSTR,
    usri3_password_age: DWORD,
    usri3_priv: DWORD,
    usri3_home_dir: LPWSTR,
    usri3_comment: LPWSTR,
    usri3_flags: DWORD,
    usri3_script_path: LPWSTR,
    usri3_auth_flags: DWORD,
    usri3_full_name: LPWSTR,
    usri3_usr_comment: LPWSTR,
    usri3_parms: LPWSTR,
    usri3_workstations: LPWSTR,
    usri3_last_logon: DWORD,
    usri3_last_logoff: DWORD,
    usri3_acct_expires: DWORD,
    usri3_max_storage: DWORD,
    usri3_units_per_week: DWORD,
    usri3_logon_hours: PBYTE,
    usri3_bad_pw_count: DWORD,
    usri3_num_logons: DWORD,
    usri3_logon_server: LPWSTR,
    usri3_country_code: DWORD,
    usri3_code_page: DWORD,
    usri3_user_id: DWORD,
    usri3_primary_group_id: DWORD,
    usri3_profile: LPWSTR,
    usri3_home_dir_drive: LPWSTR,
    usri3_password_expired: DWORD,
}}
pub type PUSER_INFO_3 = *mut USER_INFO_3;
pub type LPUSER_INFO_3 = *mut USER_INFO_3;
STRUCT!{struct USER_INFO_4 {
    usri4_name: LPWSTR,
    usri4_password: LPWSTR,
    usri4_password_age: DWORD,
    usri4_priv: DWORD,
    usri4_home_dir: LPWSTR,
    usri4_comment: LPWSTR,
    usri4_flags: DWORD,
    usri4_script_path: LPWSTR,
    usri4_auth_flags: DWORD,
    usri4_full_name: LPWSTR,
    usri4_usr_comment: LPWSTR,
    usri4_parms: LPWSTR,
    usri4_workstations: LPWSTR,
    usri4_last_logon: DWORD,
    usri4_last_logoff: DWORD,
    usri4_acct_expires: DWORD,
    usri4_max_storage: DWORD,
    usri4_units_per_week: DWORD,
    usri4_logon_hours: PBYTE,
    usri4_bad_pw_count: DWORD,
    usri4_num_logons: DWORD,
    usri4_logon_server: LPWSTR,
    usri4_country_code: DWORD,
    usri4_code_page: DWORD,
    usri4_user_sid: PSID,
    usri4_primary_group_id: DWORD,
    usri4_profile: LPWSTR,
    usri4_home_dir_drive: LPWSTR,
    usri4_password_expired: DWORD,
}}
pub type PUSER_INFO_4 = *mut USER_INFO_4;
pub type LPUSER_INFO_4 = *mut USER_INFO_4;
STRUCT!{struct USER_INFO_10 {
    usri10_name: LPWSTR,
    usri10_comment: LPWSTR,
    usri10_usr_comment: LPWSTR,
    usri10_full_name: LPWSTR,
}}
pub type PUSER_INFO_10 = *mut USER_INFO_10;
pub type LPUSER_INFO_10 = *mut USER_INFO_10;
STRUCT!{struct USER_INFO_11 {
    usri11_name: LPWSTR,
    usri11_comment: LPWSTR,
    usri11_usr_comment: LPWSTR,
    usri11_full_name: LPWSTR,
    usri11_priv: DWORD,
    usri11_auth_flags: DWORD,
    usri11_password_age: DWORD,
    usri11_home_dir: LPWSTR,
    usri11_parms: LPWSTR,
    usri11_last_logon: DWORD,
    usri11_last_logoff: DWORD,
    usri11_bad_pw_count: DWORD,
    usri11_num_logons: DWORD,
    usri11_logon_server: LPWSTR,
    usri11_country_code: DWORD,
    usri11_workstations: LPWSTR,
    usri11_max_storage: DWORD,
    usri11_units_per_week: DWORD,
    usri11_logon_hours: PBYTE,
    usri11_code_page: DWORD,
}}
pub type PUSER_INFO_11 = *mut USER_INFO_11;
pub type LPUSER_INFO_11 = *mut USER_INFO_11;
STRUCT!{struct USER_INFO_20 {
    usri20_name: LPWSTR,
    usri20_full_name: LPWSTR,
    usri20_comment: LPWSTR,
    usri20_flags: DWORD,
    usri20_user_id: DWORD,
}}
pub type PUSER_INFO_20 = *mut USER_INFO_20;
pub type LPUSER_INFO_20 = *mut USER_INFO_20;
STRUCT!{struct USER_INFO_21 {
    usri21_password: [BYTE; ENCRYPTED_PWLEN],
}}
pub type PUSER_INFO_21 = *mut USER_INFO_21;
pub type LPUSER_INFO_21 = *mut USER_INFO_21;
STRUCT!{struct USER_INFO_22 {
    usri22_name: LPWSTR,
    usri22_password: [BYTE; ENCRYPTED_PWLEN],
    usri22_password_age: DWORD,
    usri22_priv: DWORD,
    usri22_home_dir: LPWSTR,
    usri22_comment: LPWSTR,
    usri22_flags: DWORD,
    usri22_script_path: LPWSTR,
    usri22_auth_flags: DWORD,
    usri22_full_name: LPWSTR,
    usri22_usr_comment: LPWSTR,
    usri22_parms: LPWSTR,
    usri22_workstations: LPWSTR,
    usri22_last_logon: DWORD,
    usri22_last_logoff: DWORD,
    usri22_acct_expires: DWORD,
    usri22_max_storage: DWORD,
    usri22_units_per_week: DWORD,
    usri22_logon_hours: PBYTE,
    usri22_bad_pw_count: DWORD,
    usri22_num_logons: DWORD,
    usri22_logon_server: LPWSTR,
    usri22_country_code: DWORD,
    usri22_code_page: DWORD,
}}
pub type PUSER_INFO_22 = *mut USER_INFO_22;
pub type LPUSER_INFO_22 = *mut USER_INFO_22;
STRUCT!{struct USER_INFO_23 {
    usri23_name: LPWSTR,
    usri23_full_name: LPWSTR,
    usri23_comment: LPWSTR,
    usri23_flags: DWORD,
    usri23_user_sid: PSID,
}}
pub type PUSER_INFO_23 = *mut USER_INFO_23;
pub type LPUSER_INFO_23 = *mut USER_INFO_23;
STRUCT!{struct USER_INFO_24 {
    usri24_internet_identity: BOOL,
    usri24_flags: DWORD,
    usri24_internet_provider_name: LPWSTR,
    usri24_internet_principal_name: LPWSTR,
    usri24_user_sid: PSID,
}}
pub type PUSER_INFO_24 = *mut USER_INFO_24;
pub type LPUSER_INFO_24 = *mut USER_INFO_24;
STRUCT!{struct USER_INFO_1003 {
    usri1003_password: LPWSTR,
}}
pub type PUSER_INFO_1003 = *mut USER_INFO_1003;
pub type LPUSER_INFO_1003 = *mut USER_INFO_1003;
STRUCT!{struct USER_INFO_1005 {
    usri1005_priv: DWORD,
}}
pub type PUSER_INFO_1005 = *mut USER_INFO_1005;
pub type LPUSER_INFO_1005 = *mut USER_INFO_1005;
STRUCT!{struct USER_INFO_1006 {
    usri1006_home_dir: LPWSTR,
}}
pub type PUSER_INFO_1006 = *mut USER_INFO_1006;
pub type LPUSER_INFO_1006 = *mut USER_INFO_1006;
STRUCT!{struct USER_INFO_1007 {
    usri1007_comment: LPWSTR,
}}
pub type PUSER_INFO_1007 = *mut USER_INFO_1007;
pub type LPUSER_INFO_1007 = *mut USER_INFO_1007;
STRUCT!{struct USER_INFO_1008 {
    usri1008_flags: DWORD,
}}
pub type PUSER_INFO_1008 = *mut USER_INFO_1008;
pub type LPUSER_INFO_1008 = *mut USER_INFO_1008;
STRUCT!{struct USER_INFO_1009 {
    usri1009_script_path: LPWSTR,
}}
pub type PUSER_INFO_1009 = *mut USER_INFO_1009;
pub type LPUSER_INFO_1009 = *mut USER_INFO_1009;
STRUCT!{struct USER_INFO_1010 {
    usri1010_auth_flags: DWORD,
}}
pub type PUSER_INFO_1010 = *mut USER_INFO_1010;
pub type LPUSER_INFO_1010 = *mut USER_INFO_1010;
STRUCT!{struct USER_INFO_1011 {
    usri1011_full_name: LPWSTR,
}}
pub type PUSER_INFO_1011 = *mut USER_INFO_1011;
pub type LPUSER_INFO_1011 = *mut USER_INFO_1011;
STRUCT!{struct USER_INFO_1012 {
    usri1012_usr_comment: LPWSTR,
}}
pub type PUSER_INFO_1012 = *mut USER_INFO_1012;
pub type LPUSER_INFO_1012 = *mut USER_INFO_1012;
STRUCT!{struct USER_INFO_1013 {
    usri1013_parms: LPWSTR,
}}
pub type PUSER_INFO_1013 = *mut USER_INFO_1013;
pub type LPUSER_INFO_1013 = *mut USER_INFO_1013;
STRUCT!{struct USER_INFO_1014 {
    usri1014_workstations: LPWSTR,
}}
pub type PUSER_INFO_1014 = *mut USER_INFO_1014;
pub type LPUSER_INFO_1014 = *mut USER_INFO_1014;
STRUCT!{struct USER_INFO_1017 {
    usri1017_acct_expires: DWORD,
}}
pub type PUSER_INFO_1017 = *mut USER_INFO_1017;
pub type LPUSER_INFO_1017 = *mut USER_INFO_1017;
STRUCT!{struct USER_INFO_1018 {
    usri1018_max_storage: DWORD,
}}
pub type PUSER_INFO_1018 = *mut USER_INFO_1018;
pub type LPUSER_INFO_1018 = *mut USER_INFO_1018;
STRUCT!{struct USER_INFO_1020 {
    usri1020_units_per_week: DWORD,
    usri1020_logon_hours: LPBYTE,
}}
pub type PUSER_INFO_1020 = *mut USER_INFO_1020;
pub type LPUSER_INFO_1020 = *mut USER_INFO_1020;
STRUCT!{struct USER_INFO_1023 {
    usri1023_logon_server: LPWSTR,
}}
pub type PUSER_INFO_1023 = *mut USER_INFO_1023;
pub type LPUSER_INFO_1023 = *mut USER_INFO_1023;
STRUCT!{struct USER_INFO_1024 {
    usri1024_country_code: DWORD,
}}
pub type PUSER_INFO_1024 = *mut USER_INFO_1024;
pub type LPUSER_INFO_1024 = *mut USER_INFO_1024;
STRUCT!{struct USER_INFO_1025 {
    usri1025_code_page: DWORD,
}}
pub type PUSER_INFO_1025 = *mut USER_INFO_1025;
pub type LPUSER_INFO_1025 = *mut USER_INFO_1025;
STRUCT!{struct USER_INFO_1051 {
    usri1051_primary_group_id: DWORD,
}}
pub type PUSER_INFO_1051 = *mut USER_INFO_1051;
pub type LPUSER_INFO_1051 = *mut USER_INFO_1051;
STRUCT!{struct USER_INFO_1052 {
    usri1052_profile: LPWSTR,
}}
pub type PUSER_INFO_1052 = *mut USER_INFO_1052;
pub type LPUSER_INFO_1052 = *mut USER_INFO_1052;
STRUCT!{struct USER_INFO_1053 {
    usri1053_home_dir_drive: LPWSTR,
}}
pub type PUSER_INFO_1053 = *mut USER_INFO_1053;
pub type LPUSER_INFO_1053 = *mut USER_INFO_1053;
STRUCT!{struct USER_MODALS_INFO_0 {
    usrmod0_min_passwd_len: DWORD,
    usrmod0_max_passwd_age: DWORD,
    usrmod0_min_passwd_age: DWORD,
    usrmod0_force_logoff: DWORD,
    usrmod0_password_hist_len: DWORD,
}}
pub type PUSER_MODALS_INFO_0 = *mut USER_MODALS_INFO_0;
pub type LPUSER_MODALS_INFO_0 = *mut USER_MODALS_INFO_0;
STRUCT!{struct USER_MODALS_INFO_1 {
    usrmod1_role: DWORD,
    usrmod1_primary: LPWSTR,
}}
pub type PUSER_MODALS_INFO_1 = *mut USER_MODALS_INFO_1;
pub type LPUSER_MODALS_INFO_1 = *mut USER_MODALS_INFO_1;
STRUCT!{struct USER_MODALS_INFO_2 {
    usrmod2_domain_name: LPWSTR,
    usrmod2_domain_id: PSID,
}}
pub type PUSER_MODALS_INFO_2 = *mut USER_MODALS_INFO_2;
pub type LPUSER_MODALS_INFO_2 = *mut USER_MODALS_INFO_2;
STRUCT!{struct USER_MODALS_INFO_3 {
    usrmod3_lockout_duration: DWORD,
    usrmod3_lockout_observation_window: DWORD,
    usrmod3_lockout_threshold: DWORD,
}}
pub type PUSER_MODALS_INFO_3 = *mut USER_MODALS_INFO_3;
pub type LPUSER_MODALS_INFO_3 = *mut USER_MODALS_INFO_3;
STRUCT!{struct USER_MODALS_INFO_1001 {
    usrmod1001_min_passwd_len: DWORD,
}}
pub type PUSER_MODALS_INFO_1001 = *mut USER_MODALS_INFO_1001;
pub type LPUSER_MODALS_INFO_1001 = *mut USER_MODALS_INFO_1001;
STRUCT!{struct USER_MODALS_INFO_1002 {
    usrmod1002_max_passwd_age: DWORD,
}}
pub type PUSER_MODALS_INFO_1002 = *mut USER_MODALS_INFO_1002;
pub type LPUSER_MODALS_INFO_1002 = *mut USER_MODALS_INFO_1002;
STRUCT!{struct USER_MODALS_INFO_1003 {
    usrmod1003_min_passwd_age: DWORD,
}}
pub type PUSER_MODALS_INFO_1003 = *mut USER_MODALS_INFO_1003;
pub type LPUSER_MODALS_INFO_1003 = *mut USER_MODALS_INFO_1003;
STRUCT!{struct USER_MODALS_INFO_1004 {
    usrmod1004_force_logoff: DWORD,
}}
pub type PUSER_MODALS_INFO_1004 = *mut USER_MODALS_INFO_1004;
pub type LPUSER_MODALS_INFO_1004 = *mut USER_MODALS_INFO_1004;
STRUCT!{struct USER_MODALS_INFO_1005 {
    usrmod1005_password_hist_len: DWORD,
}}
pub type PUSER_MODALS_INFO_1005 = *mut USER_MODALS_INFO_1005;
pub type LPUSER_MODALS_INFO_1005 = *mut USER_MODALS_INFO_1005;
STRUCT!{struct USER_MODALS_INFO_1006 {
    usrmod1006_role: DWORD,
}}
pub type PUSER_MODALS_INFO_1006 = *mut USER_MODALS_INFO_1006;
pub type LPUSER_MODALS_INFO_1006 = *mut USER_MODALS_INFO_1006;
STRUCT!{struct USER_MODALS_INFO_1007 {
    usrmod1007_primary: LPWSTR,
}}
pub type PUSER_MODALS_INFO_1007 = *mut USER_MODALS_INFO_1007;
pub type LPUSER_MODALS_INFO_1007 = *mut USER_MODALS_INFO_1007;
pub const UF_SCRIPT: DWORD = 0x0001;
pub const UF_ACCOUNTDISABLE: DWORD = 0x0002;
pub const UF_HOMEDIR_REQUIRED: DWORD = 0x0008;
pub const UF_LOCKOUT: DWORD = 0x0010;
pub const UF_PASSWD_NOTREQD: DWORD = 0x0020;
pub const UF_PASSWD_CANT_CHANGE: DWORD = 0x0040;
pub const UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED: DWORD = 0x0080;
pub const UF_TEMP_DUPLICATE_ACCOUNT: DWORD = 0x0100;
pub const UF_NORMAL_ACCOUNT: DWORD = 0x0200;
pub const UF_INTERDOMAIN_TRUST_ACCOUNT: DWORD = 0x0800;
pub const UF_WORKSTATION_TRUST_ACCOUNT: DWORD = 0x1000;
pub const UF_SERVER_TRUST_ACCOUNT: DWORD = 0x2000;
pub const UF_MACHINE_ACCOUNT_MASK: DWORD = UF_INTERDOMAIN_TRUST_ACCOUNT
    | UF_WORKSTATION_TRUST_ACCOUNT | UF_SERVER_TRUST_ACCOUNT;
pub const UF_ACCOUNT_TYPE_MASK: DWORD = UF_TEMP_DUPLICATE_ACCOUNT | UF_NORMAL_ACCOUNT
    | UF_INTERDOMAIN_TRUST_ACCOUNT |  UF_WORKSTATION_TRUST_ACCOUNT |  UF_SERVER_TRUST_ACCOUNT;
pub const UF_DONT_EXPIRE_PASSWD: DWORD = 0x10000;
pub const UF_MNS_LOGON_ACCOUNT: DWORD = 0x20000;
pub const UF_SMARTCARD_REQUIRED: DWORD = 0x40000;
pub const UF_TRUSTED_FOR_DELEGATION: DWORD = 0x80000;
pub const UF_NOT_DELEGATED: DWORD = 0x100000;
pub const UF_USE_DES_KEY_ONLY: DWORD = 0x200000;
pub const UF_DONT_REQUIRE_PREAUTH: DWORD = 0x400000;
pub const UF_PASSWORD_EXPIRED: DWORD = 0x800000;
pub const UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION: DWORD = 0x1000000;
pub const UF_NO_AUTH_DATA_REQUIRED: DWORD = 0x2000000;
pub const UF_PARTIAL_SECRETS_ACCOUNT: DWORD = 0x4000000;
pub const UF_USE_AES_KEYS: DWORD = 0x8000000;
pub const UF_SETTABLE_BITS: DWORD = UF_SCRIPT |  UF_ACCOUNTDISABLE |  UF_LOCKOUT
    | UF_HOMEDIR_REQUIRED | UF_PASSWD_NOTREQD | UF_PASSWD_CANT_CHANGE | UF_ACCOUNT_TYPE_MASK
    | UF_DONT_EXPIRE_PASSWD | UF_MNS_LOGON_ACCOUNT | UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED
    | UF_SMARTCARD_REQUIRED | UF_TRUSTED_FOR_DELEGATION | UF_NOT_DELEGATED | UF_USE_DES_KEY_ONLY
    | UF_DONT_REQUIRE_PREAUTH | UF_PASSWORD_EXPIRED | UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION
    | UF_NO_AUTH_DATA_REQUIRED | UF_USE_AES_KEYS | UF_PARTIAL_SECRETS_ACCOUNT;
pub const FILTER_TEMP_DUPLICATE_ACCOUNT: DWORD = 0x0001;
pub const FILTER_NORMAL_ACCOUNT: DWORD = 0x0002;
pub const FILTER_INTERDOMAIN_TRUST_ACCOUNT: DWORD = 0x0008;
pub const FILTER_WORKSTATION_TRUST_ACCOUNT: DWORD = 0x0010;
pub const FILTER_SERVER_TRUST_ACCOUNT: DWORD = 0x0020;
pub const LG_INCLUDE_INDIRECT: DWORD = 0x0001;
pub const AF_OP_PRINT: DWORD = 0x1;
pub const AF_OP_COMM: DWORD = 0x2;
pub const AF_OP_SERVER: DWORD = 0x4;
pub const AF_OP_ACCOUNTS: DWORD = 0x8;
pub const AF_SETTABLE_BITS: DWORD = AF_OP_PRINT | AF_OP_COMM | AF_OP_SERVER | AF_OP_ACCOUNTS;
pub const UAS_ROLE_STANDALONE: DWORD = 0;
pub const UAS_ROLE_MEMBER: DWORD = 1;
pub const UAS_ROLE_BACKUP: DWORD = 2;
pub const UAS_ROLE_PRIMARY: DWORD = 3;
pub const USER_NAME_PARMNUM: DWORD = 1;
pub const USER_PASSWORD_PARMNUM: DWORD = 3;
pub const USER_PASSWORD_AGE_PARMNUM: DWORD = 4;
pub const USER_PRIV_PARMNUM: DWORD = 5;
pub const USER_HOME_DIR_PARMNUM: DWORD = 6;
pub const USER_COMMENT_PARMNUM: DWORD = 7;
pub const USER_FLAGS_PARMNUM: DWORD = 8;
pub const USER_SCRIPT_PATH_PARMNUM: DWORD = 9;
pub const USER_AUTH_FLAGS_PARMNUM: DWORD = 10;
pub const USER_FULL_NAME_PARMNUM: DWORD = 11;
pub const USER_USR_COMMENT_PARMNUM: DWORD = 12;
pub const USER_PARMS_PARMNUM: DWORD = 13;
pub const USER_WORKSTATIONS_PARMNUM: DWORD = 14;
pub const USER_LAST_LOGON_PARMNUM: DWORD = 15;
pub const USER_LAST_LOGOFF_PARMNUM: DWORD = 16;
pub const USER_ACCT_EXPIRES_PARMNUM: DWORD = 17;
pub const USER_MAX_STORAGE_PARMNUM: DWORD = 18;
pub const USER_UNITS_PER_WEEK_PARMNUM: DWORD = 19;
pub const USER_LOGON_HOURS_PARMNUM: DWORD = 20;
pub const USER_PAD_PW_COUNT_PARMNUM: DWORD = 21;
pub const USER_NUM_LOGONS_PARMNUM: DWORD = 22;
pub const USER_LOGON_SERVER_PARMNUM: DWORD = 23;
pub const USER_COUNTRY_CODE_PARMNUM: DWORD = 24;
pub const USER_CODE_PAGE_PARMNUM: DWORD = 25;
pub const USER_PRIMARY_GROUP_PARMNUM: DWORD = 51;
pub const USER_PROFILE: DWORD = 52;
pub const USER_PROFILE_PARMNUM: DWORD = 52;
pub const USER_HOME_DIR_DRIVE_PARMNUM: DWORD = 53;
pub const USER_NAME_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_NAME_PARMNUM;
pub const USER_PASSWORD_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_PASSWORD_PARMNUM;
pub const USER_PASSWORD_AGE_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_PASSWORD_AGE_PARMNUM;
pub const USER_PRIV_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_PRIV_PARMNUM;
pub const USER_HOME_DIR_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_HOME_DIR_PARMNUM;
pub const USER_COMMENT_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_COMMENT_PARMNUM;
pub const USER_FLAGS_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_FLAGS_PARMNUM;
pub const USER_SCRIPT_PATH_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_SCRIPT_PATH_PARMNUM;
pub const USER_AUTH_FLAGS_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_AUTH_FLAGS_PARMNUM;
pub const USER_FULL_NAME_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_FULL_NAME_PARMNUM;
pub const USER_USR_COMMENT_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_USR_COMMENT_PARMNUM;
pub const USER_PARMS_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_PARMS_PARMNUM;
pub const USER_WORKSTATIONS_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_WORKSTATIONS_PARMNUM;
pub const USER_LAST_LOGON_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_LAST_LOGON_PARMNUM;
pub const USER_LAST_LOGOFF_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_LAST_LOGOFF_PARMNUM;
pub const USER_ACCT_EXPIRES_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_ACCT_EXPIRES_PARMNUM;
pub const USER_MAX_STORAGE_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_MAX_STORAGE_PARMNUM;
pub const USER_UNITS_PER_WEEK_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_UNITS_PER_WEEK_PARMNUM;
pub const USER_LOGON_HOURS_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_LOGON_HOURS_PARMNUM;
pub const USER_PAD_PW_COUNT_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_PAD_PW_COUNT_PARMNUM;
pub const USER_NUM_LOGONS_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_NUM_LOGONS_PARMNUM;
pub const USER_LOGON_SERVER_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_LOGON_SERVER_PARMNUM;
pub const USER_COUNTRY_CODE_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_COUNTRY_CODE_PARMNUM;
pub const USER_CODE_PAGE_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + USER_CODE_PAGE_PARMNUM;
pub const USER_PRIMARY_GROUP_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_PRIMARY_GROUP_PARMNUM;
pub const USER_HOME_DIR_DRIVE_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + USER_HOME_DIR_DRIVE_PARMNUM;
pub const TIMEQ_FOREVER: DWORD = -1i32 as DWORD;
pub const USER_MAXSTORAGE_UNLIMITED: DWORD = -1i32 as DWORD;
pub const USER_NO_LOGOFF: DWORD = -1i32 as DWORD;
pub const UNITS_PER_DAY: DWORD = 24;
pub const UNITS_PER_WEEK: DWORD = UNITS_PER_DAY * 7;
pub const USER_PRIV_MASK: DWORD = 0x3;
pub const USER_PRIV_GUEST: DWORD = 0;
pub const USER_PRIV_USER: DWORD = 1;
pub const USER_PRIV_ADMIN: DWORD = 2;
pub const MAX_PASSWD_LEN: DWORD = PWLEN;
pub const DEF_MIN_PWLEN: DWORD = 6;
pub const DEF_PWUNIQUENESS: DWORD = 5;
pub const DEF_MAX_PWHIST: DWORD = 8;
pub const DEF_MAX_PWAGE: DWORD = TIMEQ_FOREVER;
pub const DEF_MIN_PWAGE: DWORD = 0;
pub const DEF_FORCE_LOGOFF: DWORD = 0xffffffff;
pub const DEF_MAX_BADPW: DWORD = 0;
pub const ONE_DAY: DWORD = 1 * 24 * 3600;
pub const VALIDATED_LOGON: DWORD = 0;
pub const PASSWORD_EXPIRED: DWORD = 2;
pub const NON_VALIDATED_LOGON: DWORD = 3;
pub const VALID_LOGOFF: DWORD = 1;
pub const MODALS_MIN_PASSWD_LEN_PARMNUM: DWORD = 1;
pub const MODALS_MAX_PASSWD_AGE_PARMNUM: DWORD = 2;
pub const MODALS_MIN_PASSWD_AGE_PARMNUM: DWORD = 3;
pub const MODALS_FORCE_LOGOFF_PARMNUM: DWORD = 4;
pub const MODALS_PASSWD_HIST_LEN_PARMNUM: DWORD = 5;
pub const MODALS_ROLE_PARMNUM: DWORD = 6;
pub const MODALS_PRIMARY_PARMNUM: DWORD = 7;
pub const MODALS_DOMAIN_NAME_PARMNUM: DWORD = 8;
pub const MODALS_DOMAIN_ID_PARMNUM: DWORD = 9;
pub const MODALS_LOCKOUT_DURATION_PARMNUM: DWORD = 10;
pub const MODALS_LOCKOUT_OBSERVATION_WINDOW_PARMNUM: DWORD = 11;
pub const MODALS_LOCKOUT_THRESHOLD_PARMNUM: DWORD = 12;
pub const MODALS_MIN_PASSWD_LEN_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_MIN_PASSWD_LEN_PARMNUM;
pub const MODALS_MAX_PASSWD_AGE_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_MAX_PASSWD_AGE_PARMNUM;
pub const MODALS_MIN_PASSWD_AGE_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_MIN_PASSWD_AGE_PARMNUM;
pub const MODALS_FORCE_LOGOFF_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_FORCE_LOGOFF_PARMNUM;
pub const MODALS_PASSWD_HIST_LEN_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_PASSWD_HIST_LEN_PARMNUM;
pub const MODALS_ROLE_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + MODALS_ROLE_PARMNUM;
pub const MODALS_PRIMARY_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + MODALS_PRIMARY_PARMNUM;
pub const MODALS_DOMAIN_NAME_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + MODALS_DOMAIN_NAME_PARMNUM;
pub const MODALS_DOMAIN_ID_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + MODALS_DOMAIN_ID_PARMNUM;
STRUCT!{struct GROUP_INFO_0 {
    grpi0_name: LPWSTR,
}}
pub type PGROUP_INFO_0 = *mut GROUP_INFO_0;
pub type LPGROUP_INFO_0 = *mut GROUP_INFO_0;
STRUCT!{struct GROUP_INFO_1 {
    grpi1_name: LPWSTR,
    grpi1_comment: LPWSTR,
}}
pub type PGROUP_INFO_1 = *mut GROUP_INFO_1;
pub type LPGROUP_INFO_1 = *mut GROUP_INFO_1;
STRUCT!{struct GROUP_INFO_2 {
    grpi2_name: LPWSTR,
    grpi2_comment: LPWSTR,
    grpi2_group_id: DWORD,
    grpi2_attributes: DWORD,
}}
pub type PGROUP_INFO_2 = *mut GROUP_INFO_2;
STRUCT!{struct GROUP_INFO_3 {
    grpi3_name: LPWSTR,
    grpi3_comment: LPWSTR,
    grpi3_group_sid: PSID,
    grpi3_attributes: DWORD,
}}
pub type PGROUP_INFO_3 = *mut GROUP_INFO_3;
STRUCT!{struct GROUP_INFO_1002 {
    grpi1002_comment: LPWSTR,
}}
pub type PGROUP_INFO_1002 = *mut GROUP_INFO_1002;
pub type LPGROUP_INFO_1002 = *mut GROUP_INFO_1002;
STRUCT!{struct GROUP_INFO_1005 {
    grpi1005_attributes: DWORD,
}}
pub type PGROUP_INFO_1005 = *mut GROUP_INFO_1005;
pub type LPGROUP_INFO_1005 = *mut GROUP_INFO_1005;
STRUCT!{struct GROUP_USERS_INFO_0 {
    grui0_name: LPWSTR,
}}
pub type PGROUP_USERS_INFO_0 = *mut GROUP_USERS_INFO_0;
pub type LPGROUP_USERS_INFO_0 = *mut GROUP_USERS_INFO_0;
STRUCT!{struct GROUP_USERS_INFO_1 {
    grui1_name: LPWSTR,
    grui1_attributes: DWORD,
}}
pub type PGROUP_USERS_INFO_1 = *mut GROUP_USERS_INFO_1;
pub type LPGROUP_USERS_INFO_1 = *mut GROUP_USERS_INFO_1;
pub const GROUPIDMASK: DWORD = 0x8000;
pub const GROUP_SPECIALGRP_USERS: &'static str = "USERS";
pub const GROUP_SPECIALGRP_ADMINS: &'static str = "ADMINS";
pub const GROUP_SPECIALGRP_GUESTS: &'static str = "GUESTS";
pub const GROUP_SPECIALGRP_LOCAL: &'static str = "LOCAL";
pub const GROUP_ALL_PARMNUM: DWORD = 0;
pub const GROUP_NAME_PARMNUM: DWORD = 1;
pub const GROUP_COMMENT_PARMNUM: DWORD = 2;
pub const GROUP_ATTRIBUTES_PARMNUM: DWORD = 3;
pub const GROUP_ALL_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + GROUP_ALL_PARMNUM;
pub const GROUP_NAME_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + GROUP_NAME_PARMNUM;
pub const GROUP_COMMENT_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + GROUP_COMMENT_PARMNUM;
pub const GROUP_ATTRIBUTES_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + GROUP_ATTRIBUTES_PARMNUM;
STRUCT!{struct LOCALGROUP_INFO_0 {
    lgrpi0_name: LPWSTR,
}}
pub type PLOCALGROUP_INFO_0 = *mut LOCALGROUP_INFO_0;
pub type LPLOCALGROUP_INFO_0 = *mut LOCALGROUP_INFO_0;
STRUCT!{struct LOCALGROUP_INFO_1 {
    lgrpi1_name: LPWSTR,
    lgrpi1_comment: LPWSTR,
}}
pub type PLOCALGROUP_INFO_1 = *mut LOCALGROUP_INFO_1;
pub type LPLOCALGROUP_INFO_1 = *mut LOCALGROUP_INFO_1;
STRUCT!{struct LOCALGROUP_INFO_1002 {
    lgrpi1002_comment: LPWSTR,
}}
pub type PLOCALGROUP_INFO_1002 = *mut LOCALGROUP_INFO_1002;
pub type LPLOCALGROUP_INFO_1002 = *mut LOCALGROUP_INFO_1002;
STRUCT!{struct LOCALGROUP_MEMBERS_INFO_0 {
    lgrmi0_sid: PSID,
}}
pub type PLOCALGROUP_MEMBERS_INFO_0 = *mut LOCALGROUP_MEMBERS_INFO_0;
pub type LPLOCALGROUP_MEMBERS_INFO_0 = *mut LOCALGROUP_MEMBERS_INFO_0;
STRUCT!{struct LOCALGROUP_MEMBERS_INFO_1 {
    lgrmi1_sid: PSID,
    lgrmi1_sidusage: SID_NAME_USE,
    lgrmi1_name: LPWSTR,
}}
pub type PLOCALGROUP_MEMBERS_INFO_1 = *mut LOCALGROUP_MEMBERS_INFO_1;
pub type LPLOCALGROUP_MEMBERS_INFO_1 = *mut LOCALGROUP_MEMBERS_INFO_1;
STRUCT!{struct LOCALGROUP_MEMBERS_INFO_2 {
    lgrmi2_sid: PSID,
    lgrmi2_sidusage: SID_NAME_USE,
    lgrmi2_domainandname: LPWSTR,
}}
pub type PLOCALGROUP_MEMBERS_INFO_2 = *mut LOCALGROUP_MEMBERS_INFO_2;
pub type LPLOCALGROUP_MEMBERS_INFO_2 = *mut LOCALGROUP_MEMBERS_INFO_2;
STRUCT!{struct LOCALGROUP_MEMBERS_INFO_3 {
    lgrmi3_domainandname: LPWSTR,
}}
pub type PLOCALGROUP_MEMBERS_INFO_3 = *mut LOCALGROUP_MEMBERS_INFO_3;
pub type LPLOCALGROUP_MEMBERS_INFO_3 = *mut LOCALGROUP_MEMBERS_INFO_3;
STRUCT!{struct LOCALGROUP_USERS_INFO_0 {
    lgrui0_name: LPWSTR,
}}
pub type PLOCALGROUP_USERS_INFO_0 = *mut LOCALGROUP_USERS_INFO_0;
pub type LPLOCALGROUP_USERS_INFO_0 = *mut LOCALGROUP_USERS_INFO_0;
pub const LOCALGROUP_NAME_PARMNUM: DWORD = 1;
pub const LOCALGROUP_COMMENT_PARMNUM: DWORD = 2;
STRUCT!{struct NET_DISPLAY_USER {
    usri1_name: LPWSTR,
    usri1_comment: LPWSTR,
    usri1_flags: DWORD,
    usri1_full_name: LPWSTR,
    usri1_user_id: DWORD,
    usri1_next_index: DWORD,
}}
pub type PNET_DISPLAY_USER = *mut NET_DISPLAY_USER;
STRUCT!{struct NET_DISPLAY_MACHINE {
    usri2_name: LPWSTR,
    usri2_comment: LPWSTR,
    usri2_flags: DWORD,
    usri2_user_id: DWORD,
    usri2_next_index: DWORD,
}}
pub type PNET_DISPLAY_MACHINE = *mut NET_DISPLAY_MACHINE;
STRUCT!{struct NET_DISPLAY_GROUP {
    usri3_name: LPWSTR,
    usri3_comment: LPWSTR,
    grpi3_group_id: DWORD,
    grpi3_attributes: DWORD,
    grpi3_next_index: DWORD,
}}
pub type PNET_DISPLAY_GROUP = *mut NET_DISPLAY_GROUP;
STRUCT!{struct ACCESS_INFO_0 {
    acc0_resource_name: LPWSTR,
}}
pub type PACCESS_INFO_0 = *mut ACCESS_INFO_0;
pub type LPACCESS_INFO_0 = *mut ACCESS_INFO_0;
STRUCT!{struct ACCESS_INFO_1 {
    acc1_resource_name: LPWSTR,
    acc1_attr: DWORD,
    acc1_count: DWORD,
}}
pub type PACCESS_INFO_1 = *mut ACCESS_INFO_1;
pub type LPACCESS_INFO_1 = *mut ACCESS_INFO_1;
STRUCT!{struct ACCESS_INFO_1002 {
    acc1002_attr: DWORD,
}}
pub type PACCESS_INFO_1002 = *mut ACCESS_INFO_1002;
pub type LPACCESS_INFO_1002 = *mut ACCESS_INFO_1002;
STRUCT!{struct ACCESS_LIST {
    acl_ugname: LPWSTR,
    acl_access: DWORD,
}}
pub type PACCESS_LIST = *mut ACCESS_LIST;
pub type LPACCESS_LIST = *mut ACCESS_LIST;
pub const ACCESS_NONE: DWORD = 0;
pub const ACCESS_ALL: DWORD = ACCESS_READ | ACCESS_WRITE | ACCESS_CREATE | ACCESS_EXEC
    | ACCESS_DELETE | ACCESS_ATRIB | ACCESS_PERM;
pub const ACCESS_READ: DWORD = 0x01;
pub const ACCESS_WRITE: DWORD = 0x02;
pub const ACCESS_CREATE: DWORD = 0x04;
pub const ACCESS_EXEC: DWORD = 0x08;
pub const ACCESS_DELETE: DWORD = 0x10;
pub const ACCESS_ATRIB: DWORD = 0x20;
pub const ACCESS_PERM: DWORD = 0x40;
pub const ACCESS_GROUP: DWORD = 0x8000;
pub const ACCESS_AUDIT: DWORD = 0x1;
pub const ACCESS_SUCCESS_OPEN: DWORD = 0x10;
pub const ACCESS_SUCCESS_WRITE: DWORD = 0x20;
pub const ACCESS_SUCCESS_DELETE: DWORD = 0x40;
pub const ACCESS_SUCCESS_ACL: DWORD = 0x80;
pub const ACCESS_SUCCESS_MASK: DWORD = 0xF0;
pub const ACCESS_FAIL_OPEN: DWORD = 0x100;
pub const ACCESS_FAIL_WRITE: DWORD = 0x200;
pub const ACCESS_FAIL_DELETE: DWORD = 0x400;
pub const ACCESS_FAIL_ACL: DWORD = 0x800;
pub const ACCESS_FAIL_MASK: DWORD = 0xF00;
pub const ACCESS_FAIL_SHIFT: DWORD = 4;
pub const ACCESS_RESOURCE_NAME_PARMNUM: DWORD = 1;
pub const ACCESS_ATTR_PARMNUM: DWORD = 2;
pub const ACCESS_COUNT_PARMNUM: DWORD = 3;
pub const ACCESS_ACCESS_LIST_PARMNUM: DWORD = 4;
pub const ACCESS_RESOURCE_NAME_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + ACCESS_RESOURCE_NAME_PARMNUM;
pub const ACCESS_ATTR_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + ACCESS_ATTR_PARMNUM;
pub const ACCESS_COUNT_INFOLEVEL: DWORD = PARMNUM_BASE_INFOLEVEL + ACCESS_COUNT_PARMNUM;
pub const ACCESS_ACCESS_LIST_INFOLEVEL: DWORD =
    PARMNUM_BASE_INFOLEVEL + ACCESS_ACCESS_LIST_PARMNUM;
ENUM!{enum NET_VALIDATE_PASSWORD_TYPE {
    NetValidateAuthentication = 1,
    NetValidatePasswordChange,
    NetValidatePasswordReset,
}}
pub type PNET_VALIDATE_PASSWORD_TYPE = *mut NET_VALIDATE_PASSWORD_TYPE;
STRUCT!{struct NET_VALIDATE_PASSWORD_HASH {
    Length: ULONG,
    Hash: LPBYTE,
}}
pub type PNET_VALIDATE_PASSWORD_HASH = *mut NET_VALIDATE_PASSWORD_HASH;
pub const NET_VALIDATE_PASSWORD_LAST_SET: ULONG = 0x00000001;
pub const NET_VALIDATE_BAD_PASSWORD_TIME: ULONG = 0x00000002;
pub const NET_VALIDATE_LOCKOUT_TIME: ULONG = 0x00000004;
pub const NET_VALIDATE_BAD_PASSWORD_COUNT: ULONG = 0x00000008;
pub const NET_VALIDATE_PASSWORD_HISTORY_LENGTH: ULONG = 0x00000010;
pub const NET_VALIDATE_PASSWORD_HISTORY: ULONG = 0x00000020;
STRUCT!{struct NET_VALIDATE_PERSISTED_FIELDS {
    PresentFields: ULONG,
    PasswordLastSet: FILETIME,
    BadPasswordTime: FILETIME,
    LockoutTime: FILETIME,
    BadPasswordCount: ULONG,
    PasswordHistoryLength: ULONG,
    PasswordHistory: PNET_VALIDATE_PASSWORD_HASH,
}}
pub type PNET_VALIDATE_PERSISTED_FIELDS = *mut NET_VALIDATE_PERSISTED_FIELDS;
STRUCT!{struct NET_VALIDATE_OUTPUT_ARG {
    ChangedPersistedFields: NET_VALIDATE_PERSISTED_FIELDS,
    ValidationStatus: NET_API_STATUS,
}}
pub type PNET_VALIDATE_OUTPUT_ARG = *mut NET_VALIDATE_OUTPUT_ARG;
STRUCT!{struct NET_VALIDATE_AUTHENTICATION_INPUT_ARG {
    InputPersistedFields: NET_VALIDATE_PERSISTED_FIELDS,
    PasswordMatched: BOOLEAN,
}}
pub type PNET_VALIDATE_AUTHENTICATION_INPUT_ARG = *mut NET_VALIDATE_AUTHENTICATION_INPUT_ARG;
STRUCT!{struct NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG {
    InputPersistedFields: NET_VALIDATE_PERSISTED_FIELDS,
    ClearPassword: LPWSTR,
    UserAccountName: LPWSTR,
    HashedPassword: NET_VALIDATE_PASSWORD_HASH,
    PasswordMatch: BOOLEAN,
}}
pub type PNET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG = *mut NET_VALIDATE_PASSWORD_CHANGE_INPUT_ARG;
STRUCT!{struct NET_VALIDATE_PASSWORD_RESET_INPUT_ARG {
    InputPersistedFields: NET_VALIDATE_PERSISTED_FIELDS,
    ClearPassword: LPWSTR,
    UserAccountName: LPWSTR,
    HashedPassword: NET_VALIDATE_PASSWORD_HASH,
    PasswordMustChangeAtNextLogon: BOOLEAN,
    ClearLockout: BOOLEAN,
}}
pub type PNET_VALIDATE_PASSWORD_RESET_INPUT_ARG = *mut NET_VALIDATE_PASSWORD_RESET_INPUT_ARG;
pub const NETLOGON_CONTROL_QUERY: DWORD = 1;
pub const NETLOGON_CONTROL_REPLICATE: DWORD = 2;
pub const NETLOGON_CONTROL_SYNCHRONIZE: DWORD = 3;
pub const NETLOGON_CONTROL_PDC_REPLICATE: DWORD = 4;
pub const NETLOGON_CONTROL_REDISCOVER: DWORD = 5;
pub const NETLOGON_CONTROL_TC_QUERY: DWORD = 6;
pub const NETLOGON_CONTROL_TRANSPORT_NOTIFY: DWORD = 7;
pub const NETLOGON_CONTROL_FIND_USER: DWORD = 8;
pub const NETLOGON_CONTROL_CHANGE_PASSWORD: DWORD = 9;
pub const NETLOGON_CONTROL_TC_VERIFY: DWORD = 10;
pub const NETLOGON_CONTROL_FORCE_DNS_REG: DWORD = 11;
pub const NETLOGON_CONTROL_QUERY_DNS_REG: DWORD = 12;
pub const NETLOGON_CONTROL_UNLOAD_NETLOGON_DLL: DWORD = 0xFFFB;
pub const NETLOGON_CONTROL_BACKUP_CHANGE_LOG: DWORD = 0xFFFC;
pub const NETLOGON_CONTROL_TRUNCATE_LOG: DWORD = 0xFFFD;
pub const NETLOGON_CONTROL_SET_DBFLAG: DWORD = 0xFFFE;
pub const NETLOGON_CONTROL_BREAKPOINT: DWORD = 0xFFFF;
STRUCT!{struct NETLOGON_INFO_1 {
    netlog1_flags: DWORD,
    netlog1_pdc_connection_status: NET_API_STATUS,
}}
pub type PNETLOGON_INFO_1 = *mut NETLOGON_INFO_1;
STRUCT!{struct NETLOGON_INFO_2 {
    netlog2_flags: DWORD,
    netlog2_pdc_connection_status: NET_API_STATUS,
    netlog2_trusted_dc_name: LPWSTR,
    netlog2_tc_connection_status: NET_API_STATUS,
}}
pub type PNETLOGON_INFO_2 = *mut NETLOGON_INFO_2;
STRUCT!{struct NETLOGON_INFO_3 {
    netlog3_flags: DWORD,
    netlog3_logon_attempts: DWORD,
    netlog3_reserved1: DWORD,
    netlog3_reserved2: DWORD,
    netlog3_reserved3: DWORD,
    netlog3_reserved4: DWORD,
    netlog3_reserved5: DWORD,
}}
pub type PNETLOGON_INFO_3 = *mut NETLOGON_INFO_3;
STRUCT!{struct NETLOGON_INFO_4 {
    netlog4_trusted_dc_name: LPWSTR,
    netlog4_trusted_domain_name: LPWSTR,
}}
pub type PNETLOGON_INFO_4 = *mut NETLOGON_INFO_4;
pub const NETLOGON_REPLICATION_NEEDED: DWORD = 0x01;
pub const NETLOGON_REPLICATION_IN_PROGRESS: DWORD = 0x02;
pub const NETLOGON_FULL_SYNC_REPLICATION: DWORD = 0x04;
pub const NETLOGON_REDO_NEEDED: DWORD = 0x08;
pub const NETLOGON_HAS_IP: DWORD = 0x10;
pub const NETLOGON_HAS_TIMESERV: DWORD = 0x20;
pub const NETLOGON_DNS_UPDATE_FAILURE: DWORD = 0x40;
pub const NETLOGON_VERIFY_STATUS_RETURNED: DWORD = 0x80;
DEFINE_GUID!(ServiceAccountPasswordGUID, 0x262E99C9, 0x6160, 0x4871,
    0xAC, 0xEC, 0x4E, 0x61, 0x73, 0x6B, 0x6F, 0x21);
pub const SERVICE_ACCOUNT_FLAG_LINK_TO_HOST_ONLY: DWORD = 0x00000001;
pub const SERVICE_ACCOUNT_FLAG_ADD_AGAINST_RODC: DWORD = 0x00000002;
pub const SERVICE_ACCOUNT_FLAG_UNLINK_FROM_HOST_ONLY: DWORD = 0x00000001;
pub const SERVICE_ACCOUNT_FLAG_REMOVE_OFFLINE: DWORD = 0x00000002;
ENUM!{enum MSA_INFO_LEVEL {
    MsaInfoLevel0 = 0,
    MsaInfoLevelMax,
}}
pub type PMSA_INFO_LEVEL = *mut MSA_INFO_LEVEL;
ENUM!{enum MSA_INFO_STATE {
    MsaInfoNotExist = 1,
    MsaInfoNotService,
    MsaInfoCannotInstall,
    MsaInfoCanInstall,
    MsaInfoInstalled,
}}
pub type PMSA_INFO_STATE = *mut MSA_INFO_STATE;
STRUCT!{struct MSA_INFO_0 {
    State: MSA_INFO_STATE,
}}
pub type PMSA_INFO_0 = *mut MSA_INFO_0;
pub type LPMSA_INFO_0 = *mut MSA_INFO_0;


text:
namespace JFrogTFSPlugin.CustomTypes
{
    public class ArtifactoryConfiguration
    {
        public string ArtifactoryUrl { get; set; }
        public string TargetRepository { get; set; }
        public string User { get; set; }
        public string Password { get; set; }
        public string FolderToDeploy { get; set; }
        public string IncludePatterns { get; set; }
        public string ExcludePatterns { get; set; }
        public int TimeOut { get; set; }
        public bool IncludeBuildInfo { get; set; }
        public bool IsFlatDeploy { get; set; }
        public ProxyConfiguration ProxyConfiguration { get; set; }

        public override string ToString()
        {
            return ArtifactoryUrl;
        }
    }
}


text:
namespace ZE
{
	IMPLEMENT_CLASS_1(ShaderManager, ResourceManager)

	UInt8 ShaderManager::getShaderTypeByName(const char* resourceFilePath)
	{
		Int32 length = StringFunc::Length(resourceFilePath);

		if (resourceFilePath[length - 2] == 'v' && resourceFilePath[length - 1] == 's')
		{
			return Z_SHADER_VERTEX;
		}
		else if (resourceFilePath[length - 4] == 'f' && resourceFilePath[length - 3] == 'r' && resourceFilePath[length - 2] == 'a' && resourceFilePath[length - 1] == 'g')
		{
			return Z_SHADER_PIXEL;
		}
		return 0;
	}

	ShaderManager* ShaderManager::s_instance = nullptr;

	void ShaderManager::Init(GameContext* _gameContext)
	{
		Handle handle("SHADER MANAGER", sizeof(ShaderManager));
		s_instance = new(handle) ShaderManager;
		s_instance->m_gameContext = _gameContext;

		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimple.vs");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/TestGLVertexShader.vs");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/TestGLFragmentShader.frag");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimple.frag");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimpleColor.frag");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimpleLit.vs");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimpleLit.frag");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultGLSimpleLit_Blend.frag");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultHighlightSimple.vs");
		s_instance->loadResourceAsync("ZooidEngine/Shaders/DefaultHighlightSimple.frag");

		s_instance->loadAllResource();

		_gameContext->getRenderer()->AcquireRenderThreadOwnership();

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/TestGLVertexShader.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/TestGLFragmentShader.frag"), nullptr, nullptr);
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimple.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimple.frag"), nullptr, nullptr);
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimple.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimpleColor.frag"), nullptr, nullptr);
			shaderChain->m_topology = TOPOLOGY_LINE;
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimpleLit.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimpleLit.frag"), nullptr, nullptr);
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimpleLit.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultGLSimpleLit_Blend.frag"), nullptr, nullptr);
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		{
			Handle hShaderChain = _gameContext->getRenderZooid()->CreateShaderChain();
			IShaderChain* shaderChain = hShaderChain.getObject<IShaderChain>();
			shaderChain->MakeChain(s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultHighlightSimple.vs"), s_instance->getResource<IShader>("ZooidEngine/Shaders/DefaultHighlightSimple.frag"), nullptr, nullptr);
			s_instance->m_shaderChain.push_back(shaderChain);
		}

		_gameContext->getRenderer()->ReleaseRenderThreadOwnership();
	}

	void ShaderManager::Destroy()
	{
		for (int i = 0; i < s_instance->m_shaderChain.length(); i++)
		{
			s_instance->m_shaderChain[i]->Release();
		}

		if (s_instance)
		{
			s_instance->unloadResources();
		}
	}

	ZE::Handle ShaderManager::loadResource_Internal(const char* resourceFilePath)
	{

		m_gameContext->getRenderer()->AcquireRenderThreadOwnership();

		Handle hShader = m_gameContext->getRenderZooid()->CreateShader();
		IShader* pShader = hShader.getObject<IShader>();

		pShader->loadShader(resourceFilePath, getShaderTypeByName(resourceFilePath));

		m_gameContext->getRenderer()->ReleaseRenderThreadOwnership();

		return hShader;
	}

	void ShaderManager::preUnloadResource(Resource* _resource)
	{
		IShader* shader = _resource->m_hActual.getObject<IShader>();
		shader->release();
	}

	ZE::IShaderChain* ShaderManager::getShaderChain(int id)
	{
		return m_shaderChain[id];
	}

}


text:
// Code generated by go-swagger; DO NOT EDIT.

package networking

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"
	"io"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"

	"github.com/netapp/trident/storage_drivers/ontap/api/rest/models"
)

// NetworkIPBgpPeerGroupGetReader is a Reader for the NetworkIPBgpPeerGroupGet structure.
type NetworkIPBgpPeerGroupGetReader struct {
	formats strfmt.Registry
}

// ReadResponse reads a server response into the received o.
func (o *NetworkIPBgpPeerGroupGetReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
	switch response.Code() {
	case 200:
		result := NewNetworkIPBgpPeerGroupGetOK()
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		return result, nil
	default:
		result := NewNetworkIPBgpPeerGroupGetDefault(response.Code())
		if err := result.readResponse(response, consumer, o.formats); err != nil {
			return nil, err
		}
		if response.Code()/100 == 2 {
			return result, nil
		}
		return nil, result
	}
}

// NewNetworkIPBgpPeerGroupGetOK creates a NetworkIPBgpPeerGroupGetOK with default headers values
func NewNetworkIPBgpPeerGroupGetOK() *NetworkIPBgpPeerGroupGetOK {
	return &NetworkIPBgpPeerGroupGetOK{}
}

/*
NetworkIPBgpPeerGroupGetOK describes a response with status code 200, with default header values.

OK
*/
type NetworkIPBgpPeerGroupGetOK struct {
	Payload *models.BgpPeerGroup
}

// IsSuccess returns true when this network Ip bgp peer group get o k response has a 2xx status code
func (o *NetworkIPBgpPeerGroupGetOK) IsSuccess() bool {
	return true
}

// IsRedirect returns true when this network Ip bgp peer group get o k response has a 3xx status code
func (o *NetworkIPBgpPeerGroupGetOK) IsRedirect() bool {
	return false
}

// IsClientError returns true when this network Ip bgp peer group get o k response has a 4xx status code
func (o *NetworkIPBgpPeerGroupGetOK) IsClientError() bool {
	return false
}

// IsServerError returns true when this network Ip bgp peer group get o k response has a 5xx status code
func (o *NetworkIPBgpPeerGroupGetOK) IsServerError() bool {
	return false
}

// IsCode returns true when this network Ip bgp peer group get o k response a status code equal to that given
func (o *NetworkIPBgpPeerGroupGetOK) IsCode(code int) bool {
	return code == 200
}

func (o *NetworkIPBgpPeerGroupGetOK) Error() string {
	return fmt.Sprintf("[GET /network/ip/bgp/peer-groups/{uuid}][%d] networkIpBgpPeerGroupGetOK  %+v", 200, o.Payload)
}

func (o *NetworkIPBgpPeerGroupGetOK) String() string {
	return fmt.Sprintf("[GET /network/ip/bgp/peer-groups/{uuid}][%d] networkIpBgpPeerGroupGetOK  %+v", 200, o.Payload)
}

func (o *NetworkIPBgpPeerGroupGetOK) GetPayload() *models.BgpPeerGroup {
	return o.Payload
}

func (o *NetworkIPBgpPeerGroupGetOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(models.BgpPeerGroup)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}

// NewNetworkIPBgpPeerGroupGetDefault creates a NetworkIPBgpPeerGroupGetDefault with default headers values
func NewNetworkIPBgpPeerGroupGetDefault(code int) *NetworkIPBgpPeerGroupGetDefault {
	return &NetworkIPBgpPeerGroupGetDefault{
		_statusCode: code,
	}
}

/*
NetworkIPBgpPeerGroupGetDefault describes a response with status code -1, with default header values.

Error
*/
type NetworkIPBgpPeerGroupGetDefault struct {
	_statusCode int

	Payload *models.ErrorResponse
}

// Code gets the status code for the network ip bgp peer group get default response
func (o *NetworkIPBgpPeerGroupGetDefault) Code() int {
	return o._statusCode
}

// IsSuccess returns true when this network ip bgp peer group get default response has a 2xx status code
func (o *NetworkIPBgpPeerGroupGetDefault) IsSuccess() bool {
	return o._statusCode/100 == 2
}

// IsRedirect returns true when this network ip bgp peer group get default response has a 3xx status code
func (o *NetworkIPBgpPeerGroupGetDefault) IsRedirect() bool {
	return o._statusCode/100 == 3
}

// IsClientError returns true when this network ip bgp peer group get default response has a 4xx status code
func (o *NetworkIPBgpPeerGroupGetDefault) IsClientError() bool {
	return o._statusCode/100 == 4
}

// IsServerError returns true when this network ip bgp peer group get default response has a 5xx status code
func (o *NetworkIPBgpPeerGroupGetDefault) IsServerError() bool {
	return o._statusCode/100 == 5
}

// IsCode returns true when this network ip bgp peer group get default response a status code equal to that given
func (o *NetworkIPBgpPeerGroupGetDefault) IsCode(code int) bool {
	return o._statusCode == code
}

func (o *NetworkIPBgpPeerGroupGetDefault) Error() string {
	return fmt.Sprintf("[GET /network/ip/bgp/peer-groups/{uuid}][%d] network_ip_bgp_peer_group_get default  %+v", o._statusCode, o.Payload)
}

func (o *NetworkIPBgpPeerGroupGetDefault) String() string {
	return fmt.Sprintf("[GET /network/ip/bgp/peer-groups/{uuid}][%d] network_ip_bgp_peer_group_get default  %+v", o._statusCode, o.Payload)
}

func (o *NetworkIPBgpPeerGroupGetDefault) GetPayload() *models.ErrorResponse {
	return o.Payload
}

func (o *NetworkIPBgpPeerGroupGetDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {

	o.Payload = new(models.ErrorResponse)

	// response payload
	if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF {
		return err
	}

	return nil
}


text:
using System;
using Agiil.ObjectMaps;
using Autofac;
using AutoMapper;

namespace Agiil.Bootstrap.ObjectMaps
{
    public class AutomapperModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            builder
                .Register(GetMapperConfiguration)
                .SingleInstance();

            builder.Register(GetMapper);
        }

        MapperConfiguration GetMapperConfiguration(IComponentContext ctx)
            => ctx.Resolve<IMapperConfigurationFactory>().GetConfiguration();

        IMapper GetMapper(IComponentContext ctx)
        {
            var config = ctx.Resolve<MapperConfiguration>();
            var scope = ctx.Resolve<ILifetimeScope>();

            // Looking at https://github.com/AutoMapper/AutoMapper/blob/v6.0.2/src/AutoMapper/MapperConfiguration.cs#L250
            // we can see that this is a trivially cheap operation, OK to happen as often as we need.
            var mapper = config.CreateMapper(scope.Resolve);

            return mapper;
        }

    }
}


text:
angular.module('starter')

.controller('profileController', function($scope, $wakanda) {
	$wakanda.init().then(function(ds){
		ds.Profile.$all().$promise.then(function(data){
			$scope.profiles = data.result;
		});
	});
});


text:
<?php

namespace api\common;

use Yii;
use yii\rest\Serializer as BaseSerializer;
use yii\web\Link;

class Serializer extends BaseSerializer
{
    /**
     * @var string the name of the query parameter containing the information about which fields should be returned
     * for a [[Model]] object. If the parameter is not provided or empty, the default set of fields as defined
     * by [[Model::fields()]] will be returned.
     */
    public $fieldsParam = 'fields';
    /**
     * @var string the name of the query parameter containing the information about which fields should be returned
     * in addition to those listed in [[fieldsParam]] for a resource object.
     */
    public $expandParam = 'expand';
    /**
     * @var string the name of the HTTP header containing the information about total number of data items.
     * This is used when serving a resource collection with pagination.
     */
    public $totalCountHeader = 'X-Pagination-Total-Count';
    /**
     * @var string the name of the HTTP header containing the information about total number of pages of data.
     * This is used when serving a resource collection with pagination.
     */
    public $pageCountHeader = 'X-Pagination-Page-Count';
    /**
     * @var string the name of the HTTP header containing the information about the current page number (1-based).
     * This is used when serving a resource collection with pagination.
     */
    public $currentPageHeader = 'X-Pagination-Current-Page';
    /**
     * @var string the name of the HTTP header containing the information about the number of data items in each page.
     * This is used when serving a resource collection with pagination.
     */
    public $perPageHeader = 'X-Pagination-Per-Page';
    /**
     * @var string the name of the envelope (e.g. `items`) for returning the resource objects in a collection.
     * This is used when serving a resource collection. When this is set and pagination is enabled, the serializer
     * will return a collection in the following format:
     *
     * ```php
     * [
     *     'items' => [...],  // assuming collectionEnvelope is "items"
     *     '_links' => {  // pagination links as returned by Pagination::getLinks()
     *         'self' => '...',
     *         'next' => '...',
     *         'last' => '...',
     *     },
     *     '_meta' => {  // meta information as returned by Pagination::toArray()
     *         'totalCount' => 100,
     *         'pageCount' => 5,
     *         'currentPage' => 1,
     *         'perPage' => 20,
     *     },
     * ]
     * ```
     *
     * If this property is not set, the resource arrays will be directly returned without using envelope.
     * The pagination information as shown in `_links` and `_meta` can be accessed from the response HTTP headers.
     */
    public $collectionEnvelope;
    /**
     * @var string the name of the envelope (e.g. `_links`) for returning the links objects.
     * It takes effect only, if `collectionEnvelope` is set.
     * @since 2.0.4
     */
    public $linksEnvelope = 'links';
    /**
     * @var string the name of the envelope (e.g. `_meta`) for returning the pagination object.
     * It takes effect only, if `collectionEnvelope` is set.
     * @since 2.0.4
     */
    public $metaEnvelope = 'page';
    /**
     * @var Request the current request. If not set, the `request` application component will be used.
     */
    public $request;
    /**
     * @var Response the response to be sent. If not set, the `response` application component will be used.
     */
    public $response;

    /**
     * Serializes a pagination into an array.
     * @param Pagination $pagination
     * @return array the array representation of the pagination
     * @see addPaginationHeaders()
     */
    protected function serializePagination($pagination)
    {
        return [
            $this->linksEnvelope => Link::serialize($pagination->getLinks(true)),
            $this->metaEnvelope => [
                'totalCount' => $pagination->totalCount,
                'pageCount' => $pagination->getPageCount(),
                'currentPage' => $pagination->getPage() + 1,
                'perPage' => $pagination->getPageSize(),
            ],
        ];
    }

}


text:
#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \
    (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM)

#define EIGEN_USE_GPU

#include <stdio.h>

#include "tensorflow/core/kernels/betainc_op.h"

#include "tensorflow/core/framework/register_types.h"
#include "tensorflow/core/framework/tensor_types.h"

namespace tensorflow {

typedef Eigen::GpuDevice GPUDevice;

// Definition of the GPU implementations declared in betainc_op.cc.
#define DEFINE_GPU_KERNELS_NDIM(T, NDIM) \
  template struct functor::Betainc<GPUDevice, T, NDIM>;

#define DEFINE_GPU_KERNELS(T)   \
  DEFINE_GPU_KERNELS_NDIM(T, 1) \
  DEFINE_GPU_KERNELS_NDIM(T, 2)

DEFINE_GPU_KERNELS(float);
DEFINE_GPU_KERNELS(double);

}  // end namespace tensorflow

#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM


text:
#ifndef WEBRTC_MODULES_DESKTOP_CAPTURE_DESKTOP_CAPTURER_H_
#define WEBRTC_MODULES_DESKTOP_CAPTURE_DESKTOP_CAPTURER_H_

#include <stddef.h>

#include "webrtc/modules/desktop_capture/desktop_capture_types.h"

namespace webrtc {

class DesktopFrame;
class DesktopRegion;
class SharedMemory;

// Abstract interface for screen and window capturers.
class DesktopCapturer {
 public:
  // Interface that must be implemented by the DesktopCapturer consumers.
  class Callback {
   public:
    // Creates a new shared memory buffer for a frame create by the capturer.
    // Should return null shared memory is not used for captured frames (in that
    // case the capturer will allocate memory on the heap).
    virtual SharedMemory* CreateSharedMemory(size_t size) = 0;

    // Called after a frame has been captured. Handler must take ownership of
    // |frame|. If capture has failed for any reason |frame| is set to NULL
    // (e.g. the window has been closed).
    virtual void OnCaptureCompleted(DesktopFrame* frame) = 0;

   protected:
    virtual ~Callback() {}
  };

  virtual ~DesktopCapturer() {}

  // Called at the beginning of a capturing session. |callback| must remain
  // valid until capturer is destroyed.
  virtual void Start(Callback* callback) = 0;

  // Captures next frame. |region| specifies region of the capture target that
  // should be fresh in the resulting frame. The frame may also include fresh
  // data for areas outside |region|. In that case capturer will include these
  // areas in updated_region() of the frame. |region| is specified relative to
  // the top left corner of the capture target. Pending capture operations are
  // canceled when DesktopCapturer is deleted.
  virtual void Capture(const DesktopRegion& region) = 0;

  // Sets the window to be excluded from the captured image in the future
  // Capture calls. Used to exclude the screenshare notification window for
  // screen capturing.
  virtual void SetExcludedWindow(WindowId window) {}
};

}  // namespace webrtc

#endif  // WEBRTC_MODULES_DESKTOP_CAPTURE_DESKTOP_CAPTURER_H_


text:
#ifndef MOTIONBULLET_COLLISIONSHAPE_H
#define MOTIONBULLET_COLLISIONSHAPE_H

#include <MotionBullet/StdDefs.h>

#include <Base/Util/RCObject.h>
#include <Base/Util/RCP.h>

class btCollisionShape;

NAMESPACE_BEGIN

class CollisionGroup;

/*==============================================================================
   CLASS CollisionShape
==============================================================================*/
//!
class CollisionShape
   : public RCObject
{

public:

   /*----- types and enumerations ----*/

   enum {
      GROUP      = 0,
      SPHERE     = 1,
      BOX        = 2,
      CYLINDER   = 3,
      CONE       = 4,
      CONVEXHULL = 5,
      SPHEREHULL = 6,
      TRIMESH    = 7
   };

   /*----- methods -----*/

   inline uint type() const { return _type; }

protected:

   /*----- friends -----*/

   friend class CollisionGroup;
   friend class MotionWorld;
   friend class RigidBody;

   /*----- methods -----*/

   CollisionShape( uint type );
   virtual ~CollisionShape();

   virtual btCollisionShape*  bulletCollisionShape() = 0;

   /*----- data members -----*/

   uint _type;
};

NAMESPACE_END

#endif


text:
package flags

import (
	"strings"

	"github.com/digaverse/howi/pkg/vars"
)

// NewNumFlag returns new numeric flag. Argument "a" can be any nr of aliases
func NewNumFlag(name string, a ...string) *NumFlag {
	f := &NumFlag{}
	f.name = strings.TrimLeft(name, "-")
	f.aliases = append(f.aliases, f.name)
	for _, alias := range a {
		f.aliases = append(f.aliases, strings.TrimLeft(alias, "-"))
	}
	f.value = vars.Value("")
	return f
}

// NumFlag is numeric flag type with default value 0
type NumFlag struct {
	FlagCommon
}

// Parse the NumFlag
func (f *NumFlag) Parse(args *[]string) (bool, error) {
	return f.parser(args, func(v *vars.Value) {
		if v.Empty() {
			*v = vars.Value("0")
		}
	})
}


text:
.include <bsd.own.mk>

WARNS?=5
USE_SHLIBDIR=	yes

PROPLIBDIR=${NETBSDSRCDIR}/common/lib/libprop

.include "${PROPLIBDIR}/Makefile.inc"

CPPFLAGS+=-D_LIBPROP
CPPFLAGS+=-D_REENTRANT -I${NETBSDSRCDIR}/lib/libc/include

LINTFLAGS+=-w
LIB=	prop

MAN=	prop_array.3 prop_bool.3 prop_data.3 prop_dictionary.3 \
	prop_ingest.3 prop_number.3 prop_object.3 prop_string.3 proplib.3

MAN+=	prop_copyin_ioctl.9
MLINKS+= prop_copyin_ioctl.9 prop_array_copyin_ioctl.9
MLINKS+= prop_copyin_ioctl.9 prop_array_copyout_ioctl.9
MLINKS+= prop_copyin_ioctl.9 prop_dictionary_copyin_ioctl.9
MLINKS+= prop_copyin_ioctl.9 prop_dictionary_copyout_ioctl.9

MAN+=	prop_send_ioctl.3
MLINKS+= prop_send_ioctl.3 prop_array_send_ioctl.3
MLINKS+= prop_send_ioctl.3 prop_array_recv_ioctl.3
MLINKS+= prop_send_ioctl.3 prop_dictionary_send_ioctl.3
MLINKS+= prop_send_ioctl.3 prop_dictionary_recv_ioctl.3
MLINKS+= prop_send_ioctl.3 prop_dictionary_sendrecv_ioctl.3

MAN+=	prop_send_syscall.3
MLINKS+= prop_send_syscall.3 prop_array_send_syscall.3
MLINKS+= prop_send_syscall.3 prop_array_recv_syscall.3
MLINKS+= prop_send_syscall.3 prop_dictionary_send_syscall.3
MLINKS+= prop_send_syscall.3 prop_dictionary_recv_syscall.3

MAN+=	prop_dictionary_util.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_bool.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_bool.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_int8.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_uint8.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_int8.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_uint8.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_int16.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_uint16.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_int16.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_uint16.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_int32.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_uint32.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_int32.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_uint32.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_int64.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_uint64.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_int64.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_uint64.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_cstring.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_cstring.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_get_cstring_nocopy.3
MLINKS+= prop_dictionary_util.3 prop_dictionary_set_cstring_nocopy.3

MLINKS+= prop_array.3 prop_array_add.3
MLINKS+= prop_array.3 prop_array_capacity.3
MLINKS+= prop_array.3 prop_array_copy.3
MLINKS+= prop_array.3 prop_array_copy_mutable.3
MLINKS+= prop_array.3 prop_array_count.3
MLINKS+= prop_array.3 prop_array_create.3
MLINKS+= prop_array.3 prop_array_create_with_capacity.3
MLINKS+= prop_array.3 prop_array_ensure_capacity.3
MLINKS+= prop_array.3 prop_array_equals.3
MLINKS+= prop_array.3 prop_array_externalize.3
MLINKS+= prop_array.3 prop_array_externalize_to_file.3
MLINKS+= prop_array.3 prop_array_externalize_to_pref.3
MLINKS+= prop_array.3 prop_array_get.3
MLINKS+= prop_array.3 prop_array_internalize.3
MLINKS+= prop_array.3 prop_array_internalize_from_file.3
MLINKS+= prop_array.3 prop_array_internalize_from_pref.3
MLINKS+= prop_array.3 prop_array_iterator.3
MLINKS+= prop_array.3 prop_array_make_immutable.3
MLINKS+= prop_array.3 prop_array_mutable.3
MLINKS+= prop_array.3 prop_array_remove.3
MLINKS+= prop_array.3 prop_array_set.3

MAN+=	prop_array_util.3
MLINKS+= prop_array_util.3 prop_array_get_bool.3
MLINKS+= prop_array_util.3 prop_array_set_bool.3
MLINKS+= prop_array_util.3 prop_array_get_int8.3
MLINKS+= prop_array_util.3 prop_array_get_uint8.3
MLINKS+= prop_array_util.3 prop_array_set_int8.3
MLINKS+= prop_array_util.3 prop_array_set_uint8.3
MLINKS+= prop_array_util.3 prop_array_get_int16.3
MLINKS+= prop_array_util.3 prop_array_get_uint16.3
MLINKS+= prop_array_util.3 prop_array_set_int16.3
MLINKS+= prop_array_util.3 prop_array_set_uint16.3
MLINKS+= prop_array_util.3 prop_array_get_int32.3
MLINKS+= prop_array_util.3 prop_array_get_uint32.3
MLINKS+= prop_array_util.3 prop_array_set_int32.3
MLINKS+= prop_array_util.3 prop_array_set_uint32.3
MLINKS+= prop_array_util.3 prop_array_get_int64.3
MLINKS+= prop_array_util.3 prop_array_get_uint64.3
MLINKS+= prop_array_util.3 prop_array_set_int64.3
MLINKS+= prop_array_util.3 prop_array_set_uint64.3
MLINKS+= prop_array_util.3 prop_array_get_cstring.3
MLINKS+= prop_array_util.3 prop_array_set_cstring.3
MLINKS+= prop_array_util.3 prop_array_get_cstring_nocopy.3
MLINKS+= prop_array_util.3 prop_array_set_cstring_nocopy.3

MLINKS+= prop_bool.3 prop_bool_copy.3
MLINKS+= prop_bool.3 prop_bool_create.3
MLINKS+= prop_bool.3 prop_bool_true.3

MLINKS+= prop_data.3 prop_data_copy.3
MLINKS+= prop_data.3 prop_data_create_data.3
MLINKS+= prop_data.3 prop_data_create_data_nocopy.3
MLINKS+= prop_data.3 prop_data_data.3
MLINKS+= prop_data.3 prop_data_data_nocopy.3
MLINKS+= prop_data.3 prop_data_equals.3
MLINKS+= prop_data.3 prop_data_equals_data.3
MLINKS+= prop_data.3 prop_data_size.3

MLINKS+= prop_dictionary.3 prop_dictionary_all_keys.3
MLINKS+= prop_dictionary.3 prop_dictionary_capacity.3
MLINKS+= prop_dictionary.3 prop_dictionary_copy.3
MLINKS+= prop_dictionary.3 prop_dictionary_copy_mutable.3
MLINKS+= prop_dictionary.3 prop_dictionary_count.3
MLINKS+= prop_dictionary.3 prop_dictionary_create.3
MLINKS+= prop_dictionary.3 prop_dictionary_create_with_capacity.3
MLINKS+= prop_dictionary.3 prop_dictionary_ensure_capacity.3
MLINKS+= prop_dictionary.3 prop_dictionary_equals.3
MLINKS+= prop_dictionary.3 prop_dictionary_externalize.3
MLINKS+= prop_dictionary.3 prop_dictionary_externalize_to_file.3
MLINKS+= prop_dictionary.3 prop_dictionary_externalize_to_pref.3
MLINKS+= prop_dictionary.3 prop_dictionary_get.3
MLINKS+= prop_dictionary.3 prop_dictionary_get_keysym.3
MLINKS+= prop_dictionary.3 prop_dictionary_internalize.3
MLINKS+= prop_dictionary.3 prop_dictionary_internalize_from_file.3
MLINKS+= prop_dictionary.3 prop_dictionary_internalize_from_pref.3
MLINKS+= prop_dictionary.3 prop_dictionary_iterator.3
MLINKS+= prop_dictionary.3 prop_dictionary_keysym_cstring_nocopy.3
MLINKS+= prop_dictionary.3 prop_dictionary_keysym_equals.3
MLINKS+= prop_dictionary.3 prop_dictionary_make_immutable.3
MLINKS+= prop_dictionary.3 prop_dictionary_mutable.3
MLINKS+= prop_dictionary.3 prop_dictionary_remove.3
MLINKS+= prop_dictionary.3 prop_dictionary_remove_keysym.3
MLINKS+= prop_dictionary.3 prop_dictionary_set.3
MLINKS+= prop_dictionary.3 prop_dictionary_set_keysym.3

MLINKS+= prop_ingest.3 prop_ingest_context_alloc.3
MLINKS+= prop_ingest.3 prop_ingest_context_error.3
MLINKS+= prop_ingest.3 prop_ingest_context_free.3
MLINKS+= prop_ingest.3 prop_ingest_context_key.3
MLINKS+= prop_ingest.3 prop_ingest_context_private.3
MLINKS+= prop_ingest.3 prop_ingest_context_type.3
MLINKS+= prop_ingest.3 prop_dictionary_ingest.3

MLINKS+= prop_number.3 prop_number_copy.3
MLINKS+= prop_number.3 prop_number_create_integer.3
MLINKS+= prop_number.3 prop_number_create_unsigned_integer.3
MLINKS+= prop_number.3 prop_number_equals.3
MLINKS+= prop_number.3 prop_number_equals_integer.3
MLINKS+= prop_number.3 prop_number_equals_unsigned_integer.3
MLINKS+= prop_number.3 prop_number_size.3
MLINKS+= prop_number.3 prop_number_unsigned.3
MLINKS+= prop_number.3 prop_number_integer_value.3
MLINKS+= prop_number.3 prop_number_unsigned_integer_value.3

MLINKS+= prop_object.3 prop_object_equals.3
MLINKS+= prop_object.3 prop_object_iterator_next.3
MLINKS+= prop_object.3 prop_object_iterator_release.3
MLINKS+= prop_object.3 prop_object_iterator_reset.3
MLINKS+= prop_object.3 prop_object_release.3
MLINKS+= prop_object.3 prop_object_retain.3
MLINKS+= prop_object.3 prop_object_type.3

MLINKS+= prop_string.3 prop_string_append.3
MLINKS+= prop_string.3 prop_string_append_cstring.3
MLINKS+= prop_string.3 prop_string_copy.3
MLINKS+= prop_string.3 prop_string_copy_mutable.3
MLINKS+= prop_string.3 prop_string_create.3
MLINKS+= prop_string.3 prop_string_create_cstring.3
MLINKS+= prop_string.3 prop_string_create_cstring_nocopy.3
MLINKS+= prop_string.3 prop_string_cstring.3
MLINKS+= prop_string.3 prop_string_cstring_nocopy.3
MLINKS+= prop_string.3 prop_string_equals.3
MLINKS+= prop_string.3 prop_string_equals_cstring.3
MLINKS+= prop_string.3 prop_string_mutable.3
MLINKS+= prop_string.3 prop_string_size.3

.include <bsd.lib.mk>


text: This panel allows visualizing timeseries data


text:
var cdb = require('cartodb.js');
var EditFieldView = require('../edit_field_view');
var _ = require('underscore');
var $ = require('jquery');

/**
 *  Number field
 *
 *  Place to add/edit number editions
 *  - It accepts a number model with {attribute: 'colum', value: 'hello'}.
 *
 *  new NumberFieldView({
 *    model: new NumberFieldModel({ attribute: 'column', value: 'paco' }),
 *    option: false
 *  })
 */

module.exports = EditFieldView.extend({

  options: {
    template: 'common/edit_fields/number_field/number_field'
  },

  events: {
    'keydown .js-input': '_onKeyDown',
    'keyup .js-input': '_onKeyUp'
  },

  _hasSubmit: function(ev) {
    if (!ev) {
      throw new Error('event needed to check if user has submitted from the input');
    }
    return ev.keyCode === 13
  },

  _onKeyDown: function(ev) {
    if (this._hasSubmit(ev) && this.model.isValid()) {
      ev.preventDefault();
      this.trigger('onSubmit', this.model, this);
      return false;
    }
  },

  _onKeyUp: function(ev) {
    if (this._hasSubmit(ev) && this.model.isValid()) {
      ev.preventDefault();
      return false;
    }

    var value = $(ev.target).val();
    // Null values are valid for number type
    if (value === "") {
      value = null;
    }
    this.model.set('value', value);
  }

})


text:
<?php
namespace tests\domain\models\EmptyModel;
use vsc\domain\models\EmptyModel;

/**
 * @covers \vsc\domain\models\EmptyModel::setPageTitle()
 */
class setPageTitle extends \BaseUnitTest
{
	/**
	 * @covers \vsc\domain\models\EmptyModel::setPageTitle
	 */
	public function testBasicSetPageTitle()
	{
		$o = new EmptyModel();
		$sTitle = 'test title';
		$o->setPageTitle($sTitle);

		$this->assertEquals($sTitle, $o->getPageTitle());
	}
}


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tonegod.gui.listeners;

import com.jme3.input.event.MouseButtonEvent;

/**
 *
 * @author t0neg0d
 */
public interface MouseButtonListener {
	void onMouseLeftPressed(MouseButtonEvent evt);
	void onMouseLeftReleased(MouseButtonEvent evt);
	void onMouseRightPressed(MouseButtonEvent evt);
	void onMouseRightReleased(MouseButtonEvent evt);
}


text:
/* SplayTree.java */

package dict;

/**
 *  SplayTree implements a Dictionary as a binary tree that is kept roughly
 *  balanced with splay tree operations.  Multiple entries with the same key
 *  are permitted.
 *
 *  DO NOT CHANGE ANY PROTOTYPES IN THIS FILE.
 *
 *  @author Deepak Warrier and Jonathan Shewchuk
 **/
public class SplayTree implements Dictionary {

  /**
   *  size is the number of items stored in the dictionary.
   *  root is the BinaryTreeNode that serves as root of the tree.
   *  If there are no items, size is zero and root is null.
   **/
  protected int size;
  protected BinaryTreeNode root;

  /**
   *  Construct an empty splay tree.
   **/
  public SplayTree() {
    makeEmpty();
  }

  /**
   *  makeEmpty() removes all the entries from the dictionary.
   */
  @Override
  public void makeEmpty() {
    size = 0;
    root = null;
  }

  /**
   *  size() returns the number of entries stored in the dictionary.
   *
   *  @return the number of entries stored in the dictionary.
   **/
  @Override
  public int size() {
    return size;
  }

  /**
   *  isEmpty() tests if the dictionary is empty.
   *
   *  @return true if the dictionary has no entries; false otherwise.
   **/
  @Override
  public boolean isEmpty() {
    return size == 0;
  }

  /**
   *  rotateRight() rotates a node up through its parent.  It works only if
   *  "node" is a left child of its parent.
   *
   *  See lecture 36 for a description of tree rotations.
   *
   *  @param node the node to rotate up through its parent.
   **/
  private void rotateRight(BinaryTreeNode node) {
    if (node == null || node.parent == null || node.parent.leftChild != node) {
      System.out.println("Illegal call to rotateRight().  You have bug #1.");
      return;
    }

    BinaryTreeNode exParent = node.parent;
    BinaryTreeNode subtreeParent = exParent.parent;

    // Move "node"'s right subtree to its former parent.
    exParent.leftChild = node.rightChild;
    if (node.rightChild != null) {
      node.rightChild.parent = exParent;
    }

    // Make exParent become a child of "node".
    node.rightChild = exParent;
    exParent.parent = node;

    // Make "node" become a child of exParent's former parent.
    node.parent = subtreeParent;
    if (subtreeParent == null) {
      root = node;
    } else if (subtreeParent.rightChild == exParent) {
      subtreeParent.rightChild = node;
    } else {
      subtreeParent.leftChild = node;
    }
  }

  /**
   *  rotateLeft() rotates a node up through its parent.  It works only if
   *  "node" is a right child of its parent.
   *
   *  See lecture 36 for a description of tree rotations.
   *
   *  @param node the node to rotate up through its parent.
   **/
  private void rotateLeft(BinaryTreeNode node) {
    if (node == null || node.parent == null ||
        node.parent.rightChild != node) {
      System.out.println("Illegal call to rotateLeft().  You have bug #2.");
      return;
    }

    BinaryTreeNode exParent = node.parent;
    BinaryTreeNode subtreeParent = exParent.parent;

    // Move "node"'s left subtree to its former parent.
    exParent.rightChild = node.leftChild;
    if (node.leftChild != null) {
      node.leftChild.parent = exParent;
    }

    // Make exParent become a child of "node".
    node.leftChild = exParent;
    exParent.parent = node;

    // Make "node" become a child of exParent's former parent.
    node.parent = subtreeParent;
    if (subtreeParent == null) {
      root = node;
    } else if (subtreeParent.rightChild == exParent) {
      subtreeParent.rightChild = node;
    } else {
      subtreeParent.leftChild = node;
    }
  }

  /**
   *  zig() rotates "node" up through its parent.  (Note that this may entail
   *  either a rotation right or a rotation left.)
   *
   *  @param node the node to splay one step up the tree.
   **/
  private void zig(BinaryTreeNode node) {
    if (node == null || node.parent == null) {
      System.out.println("Illegal call to zig().  You have bug #3.");
      return;  // Cannot rotate.
    }

    if (node == node.parent.leftChild) {
      rotateRight(node);
    } else if (node == node.parent.rightChild) {
      rotateLeft(node);
    } else {
      System.out.println("Illegal call to zig().  You have bug #4.");
    }
  }

  /**
   *  zigZag() performs a zig-zag operation, thereby splaying "node" two steps
   *  closer to the root of the tree.
   *
   *  @param node the node to splay two steps up the tree.
   **/
  private void zigZag(BinaryTreeNode node) {
    if (node == node.parent.leftChild) {
      rotateRight(node);
      rotateLeft(node);
    } else {
      rotateLeft(node);
      rotateRight(node);
    }
  }

  /**
   *  zigZig() performs a zig-zig operation, thereby splaying "node" two
   *  steps closer to the root of the tree.  Unlike a zig-zag operation,
   *  a zig-zig operation rotates "node"'s parent up through its grandparent
   *  first, then rotates "node" up through its parent.
   *
   *  @param node the node to splay two steps up the tree.
   **/
  private void zigZig(BinaryTreeNode node) {
    if (node == node.parent.leftChild) {
      rotateRight(node.parent);
      rotateRight(node);
    } else {
      rotateLeft(node.parent);
      rotateLeft(node);
    }
  }

  /**
   *  splayNode() splays "node" to the root of the tree with a sequence of
   *  zig-zag, zig-zig, and zig operations.
   *
   *  @param node the node to splay to the root.
   **/
  private void splayNode(BinaryTreeNode node) {
    while (node.parent != null) {
      BinaryTreeNode parent = node.parent;
      BinaryTreeNode gparent = node.parent.parent;
      if (parent == root) {
        zig(node);
      } else if (parent == gparent.leftChild) {
        if (node == parent.leftChild) {
          zigZig(node);
        } else {
          zigZag(node);
        }
      } else {
        if (node == parent.leftChild) {
          zigZag(node);
        } else {
          zigZig(node);
        }
      }
    }
    // The following line isn't really necessary, as the rotations update the
    // root correctly if splayNode() successfully splays "node" to the root,
    // but it's a useful reminder.
    root = node;
  }

  /**
   *  insert() constructs and inserts a new Entry object, consisting of
   *  a (key, value) pair, into the dictionary, and returns a reference to the
   *  new Entry.  Multiple entries with the same key (or even the same key and
   *  value) can coexist in the dictionary.
   *
   *  @param key the key by which the entry can be retrieved.  Must be of
   *  a class that implements java.lang.Comparable.
   *  @param value an arbitrary object associated with the key.
   *  @return an Entry object referencing the key and value.
   **/
  @SuppressWarnings("rawtypes")
  @Override
  public Entry insert(Object key, Object value) {
    Entry entry = new Entry(key, value);
    if (root == null) {
      root = new BinaryTreeNode(entry);
    } else {
      insertHelper(entry, (Comparable) key, root);
    }

    size++;
    return entry;
  }

  /**
   *  insertHelper() recursively does the work of inserting a new Entry object
   *  into the dictionary, including calling splayNode() on the new node.
   *
   *  @param entry the Entry object to insert into the tree.
   *  @param key the key by which the entry can be retrieved.
   *  @param node the root of a subtree in which the new entry will be
   *         inserted.
   **/
  @SuppressWarnings({ "unchecked", "rawtypes" })
  private void insertHelper(Entry entry, Comparable key, BinaryTreeNode node) {
    if (key.compareTo(node.entry.key()) <= 0) {
      if (node.leftChild == null) {
        node.leftChild = new BinaryTreeNode(entry, node);
        splayNode(node.leftChild);
      } else {
        insertHelper(entry, key, node.leftChild);
      }
    } else {
      if (node.rightChild == null) {
        node.rightChild = new BinaryTreeNode(entry, node);
        splayNode(node.rightChild);
      } else {
        insertHelper(entry, key, node.rightChild);
      }
    }
  }

  /**
   *  find() searches for an entry with the specified key.  If such an entry is
   *  found, it returns the Entry object; otherwise, it returns null.  If more
   *  than one entry has the key, one of them is chosen arbitrarily and
   *  returned.
   *
   *  @param key the search key.  Must be of a class that implements
   *         java.lang.Comparable.
   *  @return an Entry referencing the key and an associated value, or null if
   *          no entry contains the specified key.
   **/
  @SuppressWarnings("rawtypes")
  @Override
  public Entry find(Object key) {
    BinaryTreeNode node = findHelper((Comparable) key, root);
    if (node == null) {
      return null;
    } else {
      return node.entry;
    }
  }

  /**
   *  Search for a node with the specified key, starting from "node".  If
   *  a matching key is found (meaning that key1.compareTo(key2) == 0), return
   *  a node containing that key.  Otherwise, return null.
   *
   *  Be sure this method returns null if node == null.
   **/

  @SuppressWarnings({ "rawtypes", "unchecked" })
  private BinaryTreeNode findHelper(Comparable key, BinaryTreeNode node) {
    if (node == null) {
      return null;
    }

    if (key.compareTo(node.entry.key()) < 0) {  // "key" < "node"'s key
      if (node.leftChild == null) {
        splayNode(node);  // Splay the last node visited to the root.
        return null;
      }
      return findHelper(key, node.leftChild);
    } else if (key.compareTo(node.entry.key()) > 0) { // "key" > "node"'s key
      if (node.rightChild == null) {
        splayNode(node);  // Splay the last node visited to the root.
        return null;
      }
      return findHelper(key, node.rightChild);
    } else { // "key" == "node"'s key
      splayNode(node);  // Splay the found node to the root.
      return node;
    }
  }

  /**
   *  remove() searches for an entry with the specified key.  If such an entry
   *  is found, it removes the Entry object from the Dictionary and returns it;
   *  otherwise, it returns null.  If more than one entry has the key, one of
   *  them is chosen arbitrarily, removed, and returned.
   *
   *  @param key the search key.  Must be of a class that implements
   *         java.lang.Comparable.
   *  @return an Entry referencing the key and an associated value, or null if
   *          no entry contains the specified key.
   **/
  @Override
  public Entry remove(Object key) {
    //  Not implemented.
    return null;
  }

  /**
   *  Convert the tree into a string.
   **/

  @Override
  public String toString() {
    if (root == null) {
      return "";
    } else {
      return root.toString();
    }
  }

  private static void makeUnbalancedTree(SplayTree tree) {
    tree.insert(new Integer(10), "A");
    tree.insert(new Integer(9), "B");
    tree.insert(new Integer(8), "C");
    tree.insert(new Integer(7), "D");
    tree.insert(new Integer(6), "E");
    tree.insert(new Integer(5), "F");
    tree.insert(new Integer(4), "G");
    tree.insert(new Integer(3), "H");
    tree.insert(new Integer(2), "I");
    tree.insert(new Integer(1), "J");
  }

  /**
   *  main() tests the splay tree.
   *
   * DO NOT CHANGE THE FOLLOWING TEST CODE!
   **/
  @SuppressWarnings("rawtypes")
  public static void main(String[] args) {
    SplayTree tree = new SplayTree();

    System.out.println("\nPART I:  Testing zigZig()\n");
    String shouldBe = null;

    System.out.println("Inserting 1G, 3O, 2O, 5J, 4D, 7B, 6O into Tree 1.");
    tree.insert(new Integer(1), "G");
    tree.insert(new Integer(3), "O");
    Entry testEntry = tree.insert(new Integer(2), "O");
    BinaryTreeNode testNode =
        tree.findHelper((Comparable) testEntry.key, tree.root);
    tree.insert(new Integer(5), "J");
    tree.insert(new Integer(4), "D");
    tree.insert(new Integer(7), "B");
    tree.insert(new Integer(6), "O");
    System.out.println("Tree 1 is:  " + tree);

    if (tree.toString().equals("(((((1G)2O)3O)4D)5J)6O(7B)")) {
      System.out.println("Skipping the rest of Part I.");
    } else if (tree.toString().equals("(((1G)2O(3O))4D(5J))6O(7B)")) {
      System.out.println("\nPerforming zig-zig on node with key 2.");
      tree.zigZig(testNode);
      System.out.println("Tree 1 is now:  " + tree);
      shouldBe = "(1G)2O((3O)4D((5J)6O(7B)))";
      if (tree.toString().equals(shouldBe)) {
        System.out.println("  Zig-zig successful.");
      } else {
        System.out.println("  ERROR:  SHOULD BE " + shouldBe);
      }
      System.out.println("\nAttempting to balance an unbalanced tree using only zig():");
      SplayTree unbalanced = new SplayTree();
      makeUnbalancedTree(unbalanced);
      System.out.println("\nInserting 10A, 9B, 8C, 7D, 6E, 5F, 4G, 3H, 2I, 1J");
      System.out.println("tree is:  " + unbalanced);
      shouldBe = "1J(2I(3H(4G(5F(6E(7D(8C(9B(10A)))))))))";
      if (!unbalanced.toString().equals(shouldBe)) {
        System.out.println("  ERROR:  SHOULD BE " + shouldBe);
      }
      unbalanced.testFind(10, "A");
      System.out.println("Tree 1 is now:  " + unbalanced);
      shouldBe = "(1J(2I(3H(4G(5F(6E(7D(8C(9B)))))))))10A";
      if (!unbalanced.toString().equals(shouldBe)) {
        System.out.println("  ERROR:  SHOULD BE " + shouldBe);
      } else {
        System.out.println("As you can see, the tree is still unbalanced.\n" +
            "If there are no errors, go on to Part II.");
      }
    } else {
      System.out.println("ERROR:  splayNode() is returning incorrect results.");
    }

    System.out.println("\nPART II:  Testing splayNode()");

    System.out.println("\nCalling splayNode() on the unbalanced tree:\n");
    System.out.println("Inserting 10A, 9B, 8C, 7D, 6E, 5F, 4G, 3H, 2I, 1J");
    SplayTree splayTest = new SplayTree();
    makeUnbalancedTree(splayTest);
    System.out.println("tree is:  " + splayTest);
    splayTest.testFind(10, "A");
    System.out.println("The tree should be better balanced now: " + splayTest);
    shouldBe = "(1J((2I)3H((4G)5F((6E)7D((8C)9B)))))10A";
    if (!splayTest.toString().equals(shouldBe)) {
      System.out.println("  ERROR:  SHOULD BE " + shouldBe);
    }

    System.out.println("\nSome find() operations on a new tree to test splayNode():\n");
    System.out.println("Inserting 3A, 7B, 4C, 2D, 9E, 1F");
    SplayTree tree2 = new SplayTree();
    tree2.insert(new Integer(3), "A");
    tree2.insert(new Integer(7), "B");
    tree2.insert(new Integer(4), "C");
    tree2.insert(new Integer(2), "D");
    tree2.insert(new Integer(9), "E");
    tree2.insert(new Integer(1), "F");
    System.out.println("Tree 2 is:  " + tree2);
    shouldBe = "1F((2D(3A((4C)7B)))9E)";
    if (!tree2.toString().equals(shouldBe)) {
      System.out.println("  ERROR:  SHOULD BE " + shouldBe);
    }
    // tree2.testRemove(2, "(1F(3A((4C)7B)))9E");
    // tree2.testRemove(4, "((1F)3A)7B(9E)");
    // tree2.testFind(1, "F");
    // tree2.testFind(9, "E");
    // shouldBe = "(1F((3A)7B))9E";
    // if (!tree2.toString().equals(shouldBe)) {
    //   System.out.println("  ERROR:  SHOULD BE " + shouldBe);
    // }
    tree2.testFind(7, "B");
    System.out.println("Tree 2 is:  " + tree2);
    shouldBe = "(1F((2D)3A(4C)))7B(9E)";
    if (!tree2.toString().equals(shouldBe)) {
      System.out.println("  ERROR:  SHOULD BE " + shouldBe);
    }
    tree2.testFind(4, "C");
    System.out.println("Tree 2 is:  " + tree2);
    shouldBe = "((1F(2D))3A)4C(7B(9E))";
    if (!tree2.toString().equals(shouldBe)) {
      System.out.println("  ERROR:  SHOULD BE " + shouldBe);
    }
  }

  private void testRemove(int n, String shouldBe) {
    Integer key = new Integer(n);
    System.out.print("After remove(" + n + "):  ");
    remove(key);
    System.out.println(this);
    if (!toString().equals(shouldBe)) {
      System.out.println("  SHOULD BE " + shouldBe);
    }
  }

  private void testFind(int n, Object truth) {
    Integer key = new Integer(n);
    Entry entry = find(key);
    System.out.println("Calling find(" + n + ")");
    if (entry == null) {
      System.out.println("  returned null.");
      if (truth != null) {
        System.out.println("  SHOULD BE " + truth + ".");
      }
    } else {
      System.out.println("  returned " + entry.value() + ".");
      if (!entry.value().equals(truth)) {
        if (truth == null) {
          System.out.println("  SHOULD BE null.");
        } else {
          System.out.println("  SHOULD BE " + truth + ".");
        }
      }
    }
  }
}


text:
package net.addictivesoftware.deploymentagent

import akka.actor._
import akka.routing.Listeners

object Dispatcher {
  def props(name: String): Props = Props(classOf[Dispatcher], name)
}

class Dispatcher extends ComposableActor with Listeners {
  receiveBuilder += {
    case Broadcast(obj:Dispatcher) => {
      //withListeners {
      //  become {
      //    obj
      //  }
      //}
    }
  }
}