repo_name
stringlengths 4
116
| path
stringlengths 4
379
| size
stringlengths 1
7
| content
stringlengths 3
1.05M
| license
stringclasses 15
values |
|---|---|---|---|---|
adarro/ddo-calc
|
subprojects/common/ddo-core/src/main/scala/io/truthencode/ddo/model/feats/Attack.scala
|
2271
|
/*
* SPDX-License-Identifier: Apache-2.0
*
* Copyright 2015-2021 Andre White.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.truthencode.ddo.model.feats
import io.truthencode.ddo.enhancement.BonusType
import io.truthencode.ddo.model.abilities.ActiveAbilities
import io.truthencode.ddo.model.effect
import io.truthencode.ddo.model.effect.TriggerEvent
import io.truthencode.ddo.model.effect.features.{FeaturesImpl, GrantAbilityFeature}
import io.truthencode.ddo.support.requisite.{FeatRequisiteImpl, FreeFeat}
import java.time.Duration
/**
* [[https://ddowiki.com/page/Attack Attack]] This is the standard attack for all characters. It can
* be toggled on to attack repeatedly until your target is defeated, or activated once by
* right-clicking the mouse.
* @note
* Currently set to No Cooldown, aside from potential advanced metrics, this shouldn't be an
* issue.
*/
protected[feats] trait Attack
extends FeatRequisiteImpl with ActiveFeat with FreeFeat with Stance with FeaturesImpl
with GrantAbilityFeature {
self: GeneralFeat =>
override lazy val grantedAbility: ActiveAbilities = ActiveAbilities.Attack
override protected[this] lazy val triggerOn: Seq[TriggerEvent] = Seq(TriggerEvent.OnToggle)
override protected[this] lazy val triggerOff: Seq[TriggerEvent] = Seq(TriggerEvent.OnToggle)
override protected[this] lazy val grantAbilityCategories: Seq[effect.EffectCategories.Value] =
Seq(effect.EffectCategories.Stance)
override val grantBonusType: BonusType = BonusType.Feat
override val abilityId: String = "Attack"
override val description: String = "Toggles auto - continuous attack on / off."
override def coolDown: Option[Duration] = None
}
|
apache-2.0
|
dawidcieszynski/ZXing.Net
|
Source/lib/client/result/SMTPResultParser.cs
|
1956
|
/*
* Copyright 2010 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
namespace ZXing.Client.Result
{
/// <summary>
/// <p>Parses an "smtp:" URI result, whose format is not standardized but appears to be like:
/// <code>smtp[:subject[:body]]}</code>.</p>
/// <p>See http://code.google.com/p/zxing/issues/detail?id=536</p>
/// </summary>
/// <author>Sean Owen</author>
public class SMTPResultParser : ResultParser
{
override public ParsedResult parse(ZXing.Result result)
{
String rawText = result.Text;
if (!(rawText.StartsWith("smtp:") || rawText.StartsWith("SMTP:")))
{
return null;
}
String emailAddress = rawText.Substring(5);
String subject = null;
String body = null;
int colon = emailAddress.IndexOf(':');
if (colon >= 0)
{
subject = emailAddress.Substring(colon + 1);
emailAddress = emailAddress.Substring(0, colon);
colon = subject.IndexOf(':');
if (colon >= 0)
{
body = subject.Substring(colon + 1);
subject = subject.Substring(0, colon);
}
}
String mailtoURI = "mailto:" + emailAddress;
return new EmailAddressParsedResult(emailAddress, subject, body, mailtoURI);
}
}
}
|
apache-2.0
|
dims/nova
|
nova/tests/unit/test_nova_manage.py
|
27766
|
# Copyright 2011 OpenStack Foundation
# Copyright 2011 Ilya Alekseyev
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from six.moves import StringIO
import sys
import fixtures
import mock
from nova.cmd import manage
from nova import context
from nova import db
from nova.db import migration
from nova.db.sqlalchemy import migration as sqla_migration
from nova import exception
from nova import objects
from nova import test
from nova.tests.unit.db import fakes as db_fakes
from nova.tests.unit import fake_instance
from nova.tests.unit.objects import test_network
from nova.tests.unit import test_flavors
class FixedIpCommandsTestCase(test.TestCase):
def setUp(self):
super(FixedIpCommandsTestCase, self).setUp()
db_fakes.stub_out_db_network_api(self)
self.commands = manage.FixedIpCommands()
def test_reserve(self):
self.commands.reserve('192.168.0.100')
address = db.fixed_ip_get_by_address(context.get_admin_context(),
'192.168.0.100')
self.assertTrue(address['reserved'])
def test_reserve_nonexistent_address(self):
self.assertEqual(2, self.commands.reserve('55.55.55.55'))
def test_unreserve(self):
self.commands.unreserve('192.168.0.100')
address = db.fixed_ip_get_by_address(context.get_admin_context(),
'192.168.0.100')
self.assertFalse(address['reserved'])
def test_unreserve_nonexistent_address(self):
self.assertEqual(2, self.commands.unreserve('55.55.55.55'))
def test_list(self):
self.useFixture(fixtures.MonkeyPatch('sys.stdout',
StringIO()))
self.commands.list()
self.assertNotEqual(1, sys.stdout.getvalue().find('192.168.0.100'))
def test_list_just_one_host(self):
def fake_fixed_ip_get_by_host(*args, **kwargs):
return [db_fakes.fixed_ip_fields]
self.useFixture(fixtures.MonkeyPatch(
'nova.db.fixed_ip_get_by_host',
fake_fixed_ip_get_by_host))
self.useFixture(fixtures.MonkeyPatch('sys.stdout',
StringIO()))
self.commands.list('banana')
self.assertNotEqual(1, sys.stdout.getvalue().find('192.168.0.100'))
class FloatingIpCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(FloatingIpCommandsTestCase, self).setUp()
db_fakes.stub_out_db_network_api(self)
self.commands = manage.FloatingIpCommands()
def test_address_to_hosts(self):
def assert_loop(result, expected):
for ip in result:
self.assertIn(str(ip), expected)
address_to_hosts = self.commands.address_to_hosts
# /32 and /31
self.assertRaises(exception.InvalidInput, address_to_hosts,
'192.168.100.1/32')
self.assertRaises(exception.InvalidInput, address_to_hosts,
'192.168.100.1/31')
# /30
expected = ["192.168.100.%s" % i for i in range(1, 3)]
result = address_to_hosts('192.168.100.0/30')
self.assertEqual(2, len(list(result)))
assert_loop(result, expected)
# /29
expected = ["192.168.100.%s" % i for i in range(1, 7)]
result = address_to_hosts('192.168.100.0/29')
self.assertEqual(6, len(list(result)))
assert_loop(result, expected)
# /28
expected = ["192.168.100.%s" % i for i in range(1, 15)]
result = address_to_hosts('192.168.100.0/28')
self.assertEqual(14, len(list(result)))
assert_loop(result, expected)
# /16
result = address_to_hosts('192.168.100.0/16')
self.assertEqual(65534, len(list(result)))
# NOTE(dripton): I don't test /13 because it makes the test take 3s.
# /12 gives over a million IPs, which is ridiculous.
self.assertRaises(exception.InvalidInput, address_to_hosts,
'192.168.100.1/12')
class NetworkCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(NetworkCommandsTestCase, self).setUp()
self.commands = manage.NetworkCommands()
self.net = {'id': 0,
'label': 'fake',
'injected': False,
'cidr': '192.168.0.0/24',
'cidr_v6': 'dead:beef::/64',
'multi_host': False,
'gateway_v6': 'dead:beef::1',
'netmask_v6': '64',
'netmask': '255.255.255.0',
'bridge': 'fa0',
'bridge_interface': 'fake_fa0',
'gateway': '192.168.0.1',
'broadcast': '192.168.0.255',
'dns1': '8.8.8.8',
'dns2': '8.8.4.4',
'vlan': 200,
'vlan_start': 201,
'vpn_public_address': '10.0.0.2',
'vpn_public_port': '2222',
'vpn_private_address': '192.168.0.2',
'dhcp_start': '192.168.0.3',
'project_id': 'fake_project',
'host': 'fake_host',
'uuid': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}
def fake_network_get_by_cidr(context, cidr):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(cidr, self.fake_net['cidr'])
return db_fakes.FakeModel(dict(test_network.fake_network,
**self.fake_net))
def fake_network_get_by_uuid(context, uuid):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(uuid, self.fake_net['uuid'])
return db_fakes.FakeModel(dict(test_network.fake_network,
**self.fake_net))
def fake_network_update(context, network_id, values):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(network_id, self.fake_net['id'])
self.assertEqual(values, self.fake_update_value)
self.fake_network_get_by_cidr = fake_network_get_by_cidr
self.fake_network_get_by_uuid = fake_network_get_by_uuid
self.fake_network_update = fake_network_update
def test_create(self):
def fake_create_networks(obj, context, **kwargs):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(kwargs['label'], 'Test')
self.assertEqual(kwargs['cidr'], '10.2.0.0/24')
self.assertFalse(kwargs['multi_host'])
self.assertEqual(kwargs['num_networks'], 1)
self.assertEqual(kwargs['network_size'], 256)
self.assertEqual(kwargs['vlan'], 200)
self.assertEqual(kwargs['vlan_start'], 201)
self.assertEqual(kwargs['vpn_start'], 2000)
self.assertEqual(kwargs['cidr_v6'], 'fd00:2::/120')
self.assertEqual(kwargs['gateway'], '10.2.0.1')
self.assertEqual(kwargs['gateway_v6'], 'fd00:2::22')
self.assertEqual(kwargs['bridge'], 'br200')
self.assertEqual(kwargs['bridge_interface'], 'eth0')
self.assertEqual(kwargs['dns1'], '8.8.8.8')
self.assertEqual(kwargs['dns2'], '8.8.4.4')
self.flags(network_manager='nova.network.manager.VlanManager')
from nova.network import manager as net_manager
self.stubs.Set(net_manager.VlanManager, 'create_networks',
fake_create_networks)
self.commands.create(
label='Test',
cidr='10.2.0.0/24',
num_networks=1,
network_size=256,
multi_host='F',
vlan=200,
vlan_start=201,
vpn_start=2000,
cidr_v6='fd00:2::/120',
gateway='10.2.0.1',
gateway_v6='fd00:2::22',
bridge='br200',
bridge_interface='eth0',
dns1='8.8.8.8',
dns2='8.8.4.4',
uuid='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')
def test_list(self):
def fake_network_get_all(context):
return [db_fakes.FakeModel(self.net)]
self.stub_out('nova.db.network_get_all', fake_network_get_all)
output = StringIO()
sys.stdout = output
self.commands.list()
sys.stdout = sys.__stdout__
result = output.getvalue()
_fmt = "\t".join(["%(id)-5s", "%(cidr)-18s", "%(cidr_v6)-15s",
"%(dhcp_start)-15s", "%(dns1)-15s", "%(dns2)-15s",
"%(vlan)-15s", "%(project_id)-15s", "%(uuid)-15s"])
head = _fmt % {'id': 'id',
'cidr': 'IPv4',
'cidr_v6': 'IPv6',
'dhcp_start': 'start address',
'dns1': 'DNS1',
'dns2': 'DNS2',
'vlan': 'VlanID',
'project_id': 'project',
'uuid': "uuid"}
body = _fmt % {'id': self.net['id'],
'cidr': self.net['cidr'],
'cidr_v6': self.net['cidr_v6'],
'dhcp_start': self.net['dhcp_start'],
'dns1': self.net['dns1'],
'dns2': self.net['dns2'],
'vlan': self.net['vlan'],
'project_id': self.net['project_id'],
'uuid': self.net['uuid']}
answer = '%s\n%s\n' % (head, body)
self.assertEqual(result, answer)
def test_delete(self):
self.fake_net = self.net
self.fake_net['project_id'] = None
self.fake_net['host'] = None
self.stub_out('nova.db.network_get_by_uuid',
self.fake_network_get_by_uuid)
def fake_network_delete_safe(context, network_id):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(network_id, self.fake_net['id'])
self.stub_out('nova.db.network_delete_safe', fake_network_delete_safe)
self.commands.delete(uuid=self.fake_net['uuid'])
def test_delete_by_cidr(self):
self.fake_net = self.net
self.fake_net['project_id'] = None
self.fake_net['host'] = None
self.stub_out('nova.db.network_get_by_cidr',
self.fake_network_get_by_cidr)
def fake_network_delete_safe(context, network_id):
self.assertTrue(context.to_dict()['is_admin'])
self.assertEqual(network_id, self.fake_net['id'])
self.stub_out('nova.db.network_delete_safe', fake_network_delete_safe)
self.commands.delete(fixed_range=self.fake_net['cidr'])
def _test_modify_base(self, update_value, project, host, dis_project=None,
dis_host=None):
self.fake_net = self.net
self.fake_update_value = update_value
self.stub_out('nova.db.network_get_by_cidr',
self.fake_network_get_by_cidr)
self.stub_out('nova.db.network_update', self.fake_network_update)
self.commands.modify(self.fake_net['cidr'], project=project, host=host,
dis_project=dis_project, dis_host=dis_host)
def test_modify_associate(self):
self._test_modify_base(update_value={'project_id': 'test_project',
'host': 'test_host'},
project='test_project', host='test_host')
def test_modify_unchanged(self):
self._test_modify_base(update_value={}, project=None, host=None)
def test_modify_disassociate(self):
self._test_modify_base(update_value={'project_id': None, 'host': None},
project=None, host=None, dis_project=True,
dis_host=True)
class NeutronV2NetworkCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(NeutronV2NetworkCommandsTestCase, self).setUp()
self.flags(network_api_class='nova.network.neutronv2.api.API')
self.commands = manage.NetworkCommands()
def test_create(self):
self.assertEqual(2, self.commands.create())
def test_list(self):
self.assertEqual(2, self.commands.list())
def test_delete(self):
self.assertEqual(2, self.commands.delete())
def test_modify(self):
self.assertEqual(2, self.commands.modify('192.168.0.1'))
class ProjectCommandsTestCase(test.TestCase):
def setUp(self):
super(ProjectCommandsTestCase, self).setUp()
self.commands = manage.ProjectCommands()
def test_quota(self):
output = StringIO()
sys.stdout = output
self.commands.quota(project_id='admin',
key='instances',
value='unlimited',
)
sys.stdout = sys.__stdout__
result = output.getvalue()
print_format = "%-36s %-10s" % ('instances', 'unlimited')
self.assertIn(print_format, result)
def test_quota_update_invalid_key(self):
self.assertEqual(2, self.commands.quota('admin', 'volumes1', '10'))
class VmCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(VmCommandsTestCase, self).setUp()
self.commands = manage.VmCommands()
self.fake_flavor = objects.Flavor(**test_flavors.DEFAULT_FLAVORS[0])
def test_list_without_host(self):
output = StringIO()
sys.stdout = output
with mock.patch.object(objects.InstanceList, 'get_by_filters') as get:
get.return_value = objects.InstanceList(
objects=[fake_instance.fake_instance_obj(
context.get_admin_context(), host='foo-host',
flavor=self.fake_flavor,
system_metadata={})])
self.commands.list()
sys.stdout = sys.__stdout__
result = output.getvalue()
self.assertIn('node', result) # check the header line
self.assertIn('m1.tiny', result) # flavor.name
self.assertIn('foo-host', result)
def test_list_with_host(self):
output = StringIO()
sys.stdout = output
with mock.patch.object(objects.InstanceList, 'get_by_host') as get:
get.return_value = objects.InstanceList(
objects=[fake_instance.fake_instance_obj(
context.get_admin_context(),
flavor=self.fake_flavor,
system_metadata={})])
self.commands.list(host='fake-host')
sys.stdout = sys.__stdout__
result = output.getvalue()
self.assertIn('node', result) # check the header line
self.assertIn('m1.tiny', result) # flavor.name
self.assertIn('fake-host', result)
class DBCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(DBCommandsTestCase, self).setUp()
self.commands = manage.DbCommands()
def test_archive_deleted_rows_negative(self):
self.assertEqual(1, self.commands.archive_deleted_rows(-1))
@mock.patch.object(db, 'archive_deleted_rows',
return_value=dict(instances=10, consoles=5))
def _test_archive_deleted_rows(self, mock_db_archive, verbose=False):
self.useFixture(fixtures.MonkeyPatch('sys.stdout', StringIO()))
self.commands.archive_deleted_rows(20, verbose=verbose)
mock_db_archive.assert_called_once_with(20)
output = sys.stdout.getvalue()
if verbose:
expected = '''\
+-----------+-------------------------+
| Table | Number of Rows Archived |
+-----------+-------------------------+
| consoles | 5 |
| instances | 10 |
+-----------+-------------------------+
'''
self.assertEqual(expected, output)
else:
self.assertEqual(0, len(output))
def test_archive_deleted_rows(self):
# Tests that we don't show any table output (not verbose).
self._test_archive_deleted_rows()
def test_archive_deleted_rows_verbose(self):
# Tests that we get table output.
self._test_archive_deleted_rows(verbose=True)
@mock.patch.object(db, 'archive_deleted_rows', return_value={})
def test_archive_deleted_rows_verbose_no_results(self, mock_db_archive):
self.useFixture(fixtures.MonkeyPatch('sys.stdout', StringIO()))
self.commands.archive_deleted_rows(20, verbose=True)
mock_db_archive.assert_called_once_with(20)
output = sys.stdout.getvalue()
self.assertIn('Nothing was archived.', output)
@mock.patch.object(migration, 'db_null_instance_uuid_scan',
return_value={'foo': 0})
def test_null_instance_uuid_scan_no_records_found(self, mock_scan):
self.useFixture(fixtures.MonkeyPatch('sys.stdout',
StringIO()))
self.commands.null_instance_uuid_scan()
self.assertIn("There were no records found", sys.stdout.getvalue())
@mock.patch.object(migration, 'db_null_instance_uuid_scan',
return_value={'foo': 1, 'bar': 0})
def _test_null_instance_uuid_scan(self, mock_scan, delete):
self.useFixture(fixtures.MonkeyPatch('sys.stdout',
StringIO()))
self.commands.null_instance_uuid_scan(delete)
output = sys.stdout.getvalue()
if delete:
self.assertIn("Deleted 1 records from table 'foo'.", output)
self.assertNotIn("Deleted 0 records from table 'bar'.", output)
else:
self.assertIn("1 records in the 'foo' table", output)
self.assertNotIn("0 records in the 'bar' table", output)
self.assertNotIn("There were no records found", output)
def test_null_instance_uuid_scan_readonly(self):
self._test_null_instance_uuid_scan(delete=False)
def test_null_instance_uuid_scan_delete(self):
self._test_null_instance_uuid_scan(delete=True)
@mock.patch.object(sqla_migration, 'db_version', return_value=2)
def test_version(self, sqla_migrate):
self.commands.version()
sqla_migrate.assert_called_once_with(database='main')
@mock.patch.object(sqla_migration, 'db_sync')
def test_sync(self, sqla_sync):
self.commands.sync(version=4)
sqla_sync.assert_called_once_with(version=4, database='main')
def _fake_db_command(self):
mock_mig_1 = mock.MagicMock(__name__="mock_mig_1")
mock_mig_2 = mock.MagicMock(__name__="mock_mig_2")
mock_mig_1.return_value = (5, 4)
mock_mig_2.return_value = (6, 6)
class _CommandSub(manage.DbCommands):
online_migrations = (
mock_mig_1,
mock_mig_2,
)
return _CommandSub
def test_online_migrations(self):
command_cls = self._fake_db_command()
command = command_cls()
command.online_data_migrations(10)
command_cls.online_migrations[0].assert_called_once_with(10)
command_cls.online_migrations[1].assert_called_once_with(6)
def test_online_migrations_no_max_count(self):
command_cls = self._fake_db_command()
command = command_cls()
command.online_data_migrations(None)
command_cls.online_migrations[0].assert_called_once_with(None)
command_cls.online_migrations[1].assert_called_once_with(None)
class ApiDbCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(ApiDbCommandsTestCase, self).setUp()
self.commands = manage.ApiDbCommands()
@mock.patch.object(sqla_migration, 'db_version', return_value=2)
def test_version(self, sqla_migrate):
self.commands.version()
sqla_migrate.assert_called_once_with(database='api')
@mock.patch.object(sqla_migration, 'db_sync')
def test_sync(self, sqla_sync):
self.commands.sync(version=4)
sqla_sync.assert_called_once_with(version=4, database='api')
class ServiceCommandsTestCase(test.TestCase):
def setUp(self):
super(ServiceCommandsTestCase, self).setUp()
self.commands = manage.ServiceCommands()
def test_service_enable_invalid_params(self):
self.assertEqual(2, self.commands.enable('nohost', 'noservice'))
def test_service_disable_invalid_params(self):
self.assertEqual(2, self.commands.disable('nohost', 'noservice'))
class CellCommandsTestCase(test.NoDBTestCase):
def setUp(self):
super(CellCommandsTestCase, self).setUp()
self.commands = manage.CellCommands()
def test_create_transport_hosts_multiple(self):
"""Test the _create_transport_hosts method
when broker_hosts is set.
"""
brokers = "127.0.0.1:5672,127.0.0.2:5671"
thosts = self.commands._create_transport_hosts(
'guest', 'devstack',
broker_hosts=brokers)
self.assertEqual(2, len(thosts))
self.assertEqual('127.0.0.1', thosts[0].hostname)
self.assertEqual(5672, thosts[0].port)
self.assertEqual('127.0.0.2', thosts[1].hostname)
self.assertEqual(5671, thosts[1].port)
def test_create_transport_hosts_single(self):
"""Test the _create_transport_hosts method when hostname is passed."""
thosts = self.commands._create_transport_hosts('guest', 'devstack',
hostname='127.0.0.1',
port=80)
self.assertEqual(1, len(thosts))
self.assertEqual('127.0.0.1', thosts[0].hostname)
self.assertEqual(80, thosts[0].port)
def test_create_transport_hosts_single_broker(self):
"""Test the _create_transport_hosts method for single broker_hosts."""
thosts = self.commands._create_transport_hosts(
'guest', 'devstack',
broker_hosts='127.0.0.1:5672')
self.assertEqual(1, len(thosts))
self.assertEqual('127.0.0.1', thosts[0].hostname)
self.assertEqual(5672, thosts[0].port)
def test_create_transport_hosts_both(self):
"""Test the _create_transport_hosts method when both broker_hosts
and hostname/port are passed.
"""
thosts = self.commands._create_transport_hosts(
'guest', 'devstack',
broker_hosts='127.0.0.1:5672',
hostname='127.0.0.2', port=80)
self.assertEqual(1, len(thosts))
self.assertEqual('127.0.0.1', thosts[0].hostname)
self.assertEqual(5672, thosts[0].port)
def test_create_transport_hosts_wrong_val(self):
"""Test the _create_transport_hosts method when broker_hosts
is wrongly sepcified
"""
self.assertRaises(ValueError,
self.commands._create_transport_hosts,
'guest', 'devstack',
broker_hosts='127.0.0.1:5672,127.0.0.1')
def test_create_transport_hosts_wrong_port_val(self):
"""Test the _create_transport_hosts method when port in
broker_hosts is wrongly sepcified
"""
self.assertRaises(ValueError,
self.commands._create_transport_hosts,
'guest', 'devstack',
broker_hosts='127.0.0.1:')
def test_create_transport_hosts_wrong_port_arg(self):
"""Test the _create_transport_hosts method when port
argument is wrongly sepcified
"""
self.assertRaises(ValueError,
self.commands._create_transport_hosts,
'guest', 'devstack',
hostname='127.0.0.1', port='ab')
@mock.patch.object(context, 'get_admin_context')
@mock.patch.object(db, 'cell_create')
def test_create_broker_hosts(self, mock_db_cell_create, mock_ctxt):
"""Test the create function when broker_hosts is
passed
"""
cell_tp_url = "fake://guest:devstack@127.0.0.1:5432"
cell_tp_url += ",guest:devstack@127.0.0.2:9999/"
ctxt = mock.sentinel
mock_ctxt.return_value = mock.sentinel
self.commands.create("test",
broker_hosts='127.0.0.1:5432,127.0.0.2:9999',
woffset=0, wscale=0,
username="guest", password="devstack")
exp_values = {'name': "test",
'is_parent': False,
'transport_url': cell_tp_url,
'weight_offset': 0.0,
'weight_scale': 0.0}
mock_db_cell_create.assert_called_once_with(ctxt, exp_values)
@mock.patch.object(context, 'get_admin_context')
@mock.patch.object(db, 'cell_create')
def test_create_broker_hosts_with_url_decoding_fix(self,
mock_db_cell_create,
mock_ctxt):
"""Test the create function when broker_hosts is
passed
"""
cell_tp_url = "fake://the=user:the=password@127.0.0.1:5432/"
ctxt = mock.sentinel
mock_ctxt.return_value = mock.sentinel
self.commands.create("test",
broker_hosts='127.0.0.1:5432',
woffset=0, wscale=0,
username="the=user",
password="the=password")
exp_values = {'name': "test",
'is_parent': False,
'transport_url': cell_tp_url,
'weight_offset': 0.0,
'weight_scale': 0.0}
mock_db_cell_create.assert_called_once_with(ctxt, exp_values)
@mock.patch.object(context, 'get_admin_context')
@mock.patch.object(db, 'cell_create')
def test_create_hostname(self, mock_db_cell_create, mock_ctxt):
"""Test the create function when hostname and port is
passed
"""
cell_tp_url = "fake://guest:devstack@127.0.0.1:9999/"
ctxt = mock.sentinel
mock_ctxt.return_value = mock.sentinel
self.commands.create("test",
hostname='127.0.0.1', port="9999",
woffset=0, wscale=0,
username="guest", password="devstack")
exp_values = {'name': "test",
'is_parent': False,
'transport_url': cell_tp_url,
'weight_offset': 0.0,
'weight_scale': 0.0}
mock_db_cell_create.assert_called_once_with(ctxt, exp_values)
|
apache-2.0
|
YaoZengzeng/runv
|
hypervisor/qemu/qemu_process.go
|
1924
|
package qemu
import (
"os"
"strings"
"github.com/golang/glog"
"github.com/hyperhq/runv/hypervisor"
"github.com/hyperhq/runv/lib/utils"
)
func watchDog(qc *QemuContext, hub chan hypervisor.VmEvent) {
wdt := qc.wdt
for {
msg, ok := <-wdt
if ok {
switch msg {
case "quit":
glog.V(1).Info("quit watch dog.")
return
case "kill":
success := false
if qc.process != nil {
glog.V(0).Infof("kill Qemu... %d", qc.process.Pid)
if err := qc.process.Kill(); err == nil {
success = true
}
} else {
glog.Warning("no process to be killed")
}
hub <- &hypervisor.VmKilledEvent{Success: success}
return
}
} else {
glog.V(1).Info("chan closed, quit watch dog.")
break
}
}
}
func (qc *QemuContext) watchPid(pid int, hub chan hypervisor.VmEvent) error {
proc, err := os.FindProcess(pid)
if err != nil {
return err
}
qc.process = proc
go watchDog(qc, hub)
return nil
}
// launchQemu run qemu and wait it's quit, includes
func launchQemu(qc *QemuContext, ctx *hypervisor.VmContext) {
qemu := qc.driver.executable
if qemu == "" {
ctx.Hub <- &hypervisor.VmStartFailEvent{Message: "can not find qemu executable"}
return
}
args := qc.arguments(ctx)
if glog.V(1) {
glog.Info("cmdline arguments: ", strings.Join(args, " "))
}
pid, err := utils.ExecInDaemon(qemu, append([]string{"qemu-system-x86_64"}, args...))
if err != nil {
//fail to daemonize
glog.Errorf("%v", err)
ctx.Hub <- &hypervisor.VmStartFailEvent{Message: "try to start qemu failed"}
return
}
glog.V(1).Infof("starting daemon with pid: %d", pid)
err = ctx.DCtx.(*QemuContext).watchPid(int(pid), ctx.Hub)
if err != nil {
glog.Error("watch qemu process failed")
ctx.Hub <- &hypervisor.VmStartFailEvent{Message: "watch qemu process failed"}
return
}
}
func associateQemu(ctx *hypervisor.VmContext) {
go watchDog(ctx.DCtx.(*QemuContext), ctx.Hub)
}
|
apache-2.0
|
FlorianKromer/TNCY-English
|
src/TNCY/SchoolBundle/Admin/ExSongAdmin.php
|
3682
|
<?php
namespace TNCY\SchoolBundle\Admin;
use Sonata\AdminBundle\Admin\Admin;
use Sonata\AdminBundle\Datagrid\ListMapper;
use Sonata\AdminBundle\Datagrid\DatagridMapper;
use Sonata\AdminBundle\Form\FormMapper;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
use Sonata\CoreBundle\Validator\ErrorElement;
use TNCY\SchoolBundle\Entity\Song;
class ExSongAdmin extends Admin
{
/** @var \Symfony\Component\DependencyInjection\ContainerInterface */
private $container;
// Fields to be shown on create/edit forms
protected function configureFormFields(FormMapper $formMapper)
{
$formMapper
->add('name', 'text', array('label' => 'Name'))
->add('artist', 'text', array('label' => 'Artist'))
->add('gaps', 'sonata_type_native_collection', array('label' => 'Word gaps','allow_add'=>true,'allow_delete'=>true))
->add('soundCloundTrackEmbed', 'textarea', array('label' => 'Song iframe embed','help'=>"Vous pouvez trouver d'une chanson sur <a href='https://soundcloud.com/'>https://soundcloud.com/</a>. "))
->add('lyrics', 'textarea', array('label' => 'Lyrics','help'=>"This fields will be automatically filled if the song was found",'required'=>false))
->setHelps(array(
'title' => ""
));
;
}
public function validate(ErrorElement $errorElement, $song)
{
if(empty($song->getLyrics())){
$musixmatchApi = $this->container->get('tncy_school.musixmatchapi');
$musixmatch = json_decode($musixmatchApi->get_musixmatch_lyrics($song->getArtist(),$song->getName()));
if ($musixmatch->message->header->status_code == 200) {
$lyrics = $musixmatch->message->body->lyrics->lyrics_body;
$song->setLyrics($lyrics);
}
else{
$error = "Error: Any lyrics was found for ".$song->getArtist()." : ".$song->getName();
$errorElement
->with('name')
->addViolation($error)
->end()
->with('artist')
->addViolation($error)
->end()
;
}
}
//TODO: rajouter un message si les mots à trouver est vide => error
}
// Fields to be shown on filter forms
protected function configureDatagridFilters(DatagridMapper $datagridMapper)
{
$datagridMapper
->add('name')
;
}
// Fields to be shown on lists
protected function configureListFields(ListMapper $listMapper)
{
$listMapper
->addIdentifier('name')
->add('artist')
->add('author')
->add('created_at')
->add('updated_at')
;
}
public function prePersist($lesson)
{
$lesson->setAuthor($this->securityToken->getToken()->getUser());
$lesson->setCreatedAt(new \DateTime());
$lesson->setUpdatedAt(new \DateTime());
}
public function preUpdate($lesson)
{
$lesson->setAuthor($this->securityToken->getToken()->getUser());
$lesson->setUpdatedAt(new \DateTime());
}
public function setSecurityToken(TokenStorage $securityToken)
{
$this->securityToken = $securityToken;
}
/**
* @return UserManagerInterface
*/
public function getSecurityToken()
{
return $this->securityToken;
}
public function setContainer (\Symfony\Component\DependencyInjection\ContainerInterface $container) {
$this->container = $container;
}
}
|
apache-2.0
|
jasonrichardcraig/DeviceSQL
|
DeviceSQL.SQLTypes.Modbus/BooleanRegisterArray.cs
|
4048
|
#region Imported Types
using Microsoft.SqlServer.Server;
using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.IO;
using System.Linq;
#endregion
namespace DeviceSQL.SQLTypes.Modbus
{
[Serializable()]
[SqlUserDefinedType(Format.UserDefined, IsByteOrdered = false, IsFixedLength = false, MaxByteSize = -1)]
public struct BooleanRegisterArray : INullable, IBinarySerialize
{
#region Fields
private List<BooleanRegister> booleanRegisters;
#endregion
#region Properties
internal BooleanRegister this[int index]
{
get
{
return BooleanRegisters[index];
}
set
{
BooleanRegisters[index] = value;
}
}
public bool IsNull
{
get;
internal set;
}
public int Length
{
get
{
return BooleanRegisters.Count;
}
}
#endregion
#region Helper Methods
private List<BooleanRegister> BooleanRegisters
{
get
{
if (booleanRegisters == null)
{
booleanRegisters = new List<BooleanRegister>();
}
return booleanRegisters;
}
}
public static BooleanRegisterArray Null
{
get
{
return (new BooleanRegisterArray() { IsNull = true });
}
}
public override string ToString()
{
return string.Join("|", BooleanRegisters.Select(booleanRegister => booleanRegister.ToString()));
}
public BooleanRegisterArray AddBooleanRegister(BooleanRegister booleanRegister)
{
BooleanRegisters.Add(booleanRegister);
return this;
}
public static BooleanRegisterArray Parse(SqlString stringToParse)
{
if (stringToParse.IsNull)
{
return Null;
}
var parsedBooleanRegisterArray = new BooleanRegisterArray()
{
booleanRegisters = new List<BooleanRegister>()
};
var parsedString = stringToParse.Value.Split("|".ToCharArray());
for (var i = 0; parsedString.Length > i; i++)
{
parsedBooleanRegisterArray.BooleanRegisters.Add(BooleanRegister.Parse(parsedString[i]));
}
return parsedBooleanRegisterArray;
}
public BooleanRegister GetBooleanRegister(SqlInt32 index)
{
return BooleanRegisters[index.Value];
}
public static BooleanRegisterArray Empty()
{
var booleanRegisterArray = new BooleanRegisterArray() { booleanRegisters = new List<BooleanRegister>() };
return booleanRegisterArray;
}
#endregion
#region Serialization Methods
public void Read(BinaryReader binaryReader)
{
BooleanRegisters.Clear();
IsNull = binaryReader.ReadBoolean();
if (IsNull)
{
return;
}
else
{
var length = binaryReader.ReadInt32();
for (var i = 0; length > i; i++)
{
var booleanRegister = new BooleanRegister();
booleanRegister.Read(binaryReader);
BooleanRegisters.Add(booleanRegister);
}
}
}
public void Write(BinaryWriter binaryWriter)
{
binaryWriter.Write(IsNull);
binaryWriter.Write(Length);
if (Length > 0)
{
for (var i = 0; BooleanRegisters.Count > i; i++)
{
BooleanRegisters[i].Write(binaryWriter);
}
}
}
#endregion
}
}
|
apache-2.0
|
phatboyg/Machete
|
src/Machete.HL7Schema/Generated/V26/Groups/Maps/DFT_P03_OBSERVATIONMap.cs
|
588
|
// This file was automatically generated and may be regenerated at any
// time. To ensure any changes are retained, modify the tool with any segment/component/group/field name
// or type changes.
namespace Machete.HL7Schema.V26.Maps
{
using V26;
/// <summary>
/// DFT_P03_OBSERVATION (GroupMap) -
/// </summary>
public class DFT_P03_OBSERVATIONMap :
HL7V26LayoutMap<DFT_P03_OBSERVATION>
{
public DFT_P03_OBSERVATIONMap()
{
Segment(x => x.OBX, 0, x => x.Required = true);
Segment(x => x.NTE, 1);
}
}
}
|
apache-2.0
|
kailee2014/kingsite
|
src/main/java/com/blooms/kingsite/modules/act/web/ActModelController.java
|
3684
|
package com.blooms.kingsite.modules.act.web;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.blooms.kingsite.common.persistence.Page;
import com.blooms.kingsite.common.web.BaseController;
import com.blooms.kingsite.modules.act.service.ActModelService;
/**
* 流程模型相关Controller
* @author Blooms
* @version 2013-11-03
*/
@Controller
@RequestMapping(value = "${adminPath}/act/model")
public class ActModelController extends BaseController {
@Autowired
private ActModelService actModelService;
/**
* 流程模型列表
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = { "list", "" })
public String modelList(String category, HttpServletRequest request, HttpServletResponse response, Model model) {
Page<org.activiti.engine.repository.Model> page = actModelService.modelList(
new Page<org.activiti.engine.repository.Model>(request, response), category);
model.addAttribute("page", page);
model.addAttribute("category", category);
return "modules/act/actModelList";
}
/**
* 创建模型
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "create", method = RequestMethod.GET)
public String create(Model model) {
return "modules/act/actModelCreate";
}
/**
* 创建模型
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "create", method = RequestMethod.POST)
public void create(String name, String key, String description, String category,
HttpServletRequest request, HttpServletResponse response) {
try {
org.activiti.engine.repository.Model modelData = actModelService.create(name, key, description, category);
response.sendRedirect(request.getContextPath() + "/act/process-editor/modeler.jsp?modelId=" + modelData.getId());
} catch (Exception e) {
e.printStackTrace();
logger.error("创建模型失败：", e);
}
}
/**
* 根据Model部署流程
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "deploy")
public String deploy(String id, RedirectAttributes redirectAttributes) {
String message = actModelService.deploy(id);
redirectAttributes.addFlashAttribute("message", message);
return "redirect:" + adminPath + "/act/process";
}
/**
* 导出model的xml文件
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "export")
public void export(String id, HttpServletResponse response) {
actModelService.export(id, response);
}
/**
* 更新Model分类
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "updateCategory")
public String updateCategory(String id, String category, RedirectAttributes redirectAttributes) {
actModelService.updateCategory(id, category);
redirectAttributes.addFlashAttribute("message", "设置成功，模块ID=" + id);
return "redirect:" + adminPath + "/act/model";
}
/**
* 删除Model
* @param id
* @param redirectAttributes
* @return
*/
@RequiresPermissions("act:model:edit")
@RequestMapping(value = "delete")
public String delete(String id, RedirectAttributes redirectAttributes) {
actModelService.delete(id);
redirectAttributes.addFlashAttribute("message", "删除成功，模型ID=" + id);
return "redirect:" + adminPath + "/act/model";
}
}
|
apache-2.0
|
Meisolsson/GitHubSdk
|
library/src/main/java/com/meisolsson/githubsdk/model/Repository.java
|
5698
|
/*
* Copyright 2015 Henrik Olsson
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.meisolsson.githubsdk.model;
import android.os.Parcelable;
import android.support.annotation.Nullable;
import com.meisolsson.githubsdk.core.FormattedTime;
import com.google.auto.value.AutoValue;
import com.squareup.moshi.Json;
import com.squareup.moshi.JsonAdapter;
import com.squareup.moshi.Moshi;
import java.util.Date;
@AutoValue
public abstract class Repository implements Parcelable {
@Nullable
public abstract String name();
@Nullable
public abstract String description();
@Nullable
public abstract String url();
@Nullable
public abstract String homepage();
@Nullable
public abstract String language();
@Nullable
public abstract Integer size();
@Nullable
public abstract Long id();
@Json(name = "fork")
@Nullable
public abstract Boolean isFork();
@Json(name = "archived")
@Nullable
public abstract Boolean isArchived();
@Nullable
public abstract User owner();
@Nullable
public abstract User organization();
@Nullable
public abstract Repository parent();
@Nullable
public abstract Repository source();
@Nullable
public abstract Permissions permissions();
@Json(name = "full_name")
@Nullable
public abstract String fullName();
@Json(name = "private")
@Nullable
public abstract Boolean isPrivate();
@Json(name = "html_url")
@Nullable
public abstract String htmlUrl();
@Json(name = "mirror_url")
@Nullable
public abstract String mirrorUrl();
@Json(name = "forks_count")
@Nullable
public abstract Integer forksCount();
@Json(name = "stargazers_count")
@Nullable
public abstract Integer stargazersCount();
@Json(name = "watchers_count")
@Nullable
public abstract Integer watchersCount();
@Json(name = "default_branch")
@Nullable
public abstract String defaultBranch();
@Json(name = "open_issues_count")
@Nullable
public abstract Integer openIssuesCount();
@Json(name = "has_issues")
@Nullable
public abstract Boolean hasIssues();
@Json(name = "has_wiki")
@Nullable
public abstract Boolean hasWiki();
@Json(name = "has_pages")
@Nullable
public abstract Boolean hasPages();
@Json(name = "has_downloads")
@Nullable
public abstract Boolean hasDownloads();
@Json(name = "pushed_at")
@Nullable
@FormattedTime
public abstract Date pushedAt();
@Json(name = "created_at")
@Nullable
@FormattedTime
public abstract Date createdAt();
@Json(name = "updated_at")
@Nullable
@FormattedTime
public abstract Date updatedAt();
@Json(name = "subscribers_count")
@Nullable
public abstract Integer subscribersCount();
public abstract Builder toBuilder();
public static JsonAdapter<Repository> jsonAdapter(Moshi moshi) {
return new AutoValue_Repository.MoshiJsonAdapter(moshi);
}
public static Builder builder() {
return new AutoValue_Repository.Builder();
}
@AutoValue.Builder
public abstract static class Builder {
public abstract Builder name(String name);
public abstract Builder description(String description);
public abstract Builder url(String url);
public abstract Builder homepage(String homepage);
public abstract Builder language(String language);
public abstract Builder size(Integer size);
public abstract Builder id(Long id);
public abstract Builder isFork(Boolean newFork);
public abstract Builder isArchived(Boolean archived);
public abstract Builder owner(User owner);
public abstract Builder organization(User organization);
public abstract Builder parent(Repository parent);
public abstract Builder source(Repository source);
public abstract Builder permissions(Permissions permissions);
public abstract Builder fullName(String fullName);
public abstract Builder isPrivate(Boolean newPrivate);
public abstract Builder htmlUrl(String htmlUrl);
public abstract Builder mirrorUrl(String mirrorUrl);
public abstract Builder forksCount(Integer forksCount);
public abstract Builder stargazersCount(Integer stargazersCount);
public abstract Builder watchersCount(Integer watchersCount);
public abstract Builder defaultBranch(String defaultBranch);
public abstract Builder openIssuesCount(Integer openIssuesCount);
public abstract Builder hasIssues(Boolean hasIssues);
public abstract Builder hasWiki(Boolean hasWiki);
public abstract Builder hasPages(Boolean hasPages);
public abstract Builder hasDownloads(Boolean hasDownloads);
public abstract Builder pushedAt(Date pushedAt);
public abstract Builder createdAt(Date createdAt);
public abstract Builder updatedAt(Date updatedAt);
public abstract Builder subscribersCount(Integer subscribersCount);
public abstract Repository build();
}
}
|
apache-2.0
|
zoozooll/Min3D
|
app/src/main/java/min3d/sampleProject1/ExampleTextureWrap.java
|
1213
|
package min3d.sampleProject1;
import min3d.Shared;
import min3d.Utils;
import min3d.core.Object3dContainer;
import min3d.core.RendererActivity;
import min3d.objectPrimitives.HollowCylinder;
import min3d.vos.TextureVo;
import android.graphics.Bitmap;
/**
* Demonstrates setting U/V texture wrapping
* (TextureVo.repeatU and TextureVo.repeatV)
*
* @author Lee
*/
public class ExampleTextureWrap extends RendererActivity
{
Object3dContainer _object;
TextureVo _texture;
int _counter;
public void initScene()
{
_object = new HollowCylinder(1f, 0.5f, 0.66f, 25);
_object.normalsEnabled(false);
_object.vertexColorsEnabled(false);
scene.addChild(_object);
Bitmap b = Utils.makeBitmapFromResourceId(R.drawable.uglysquares);
Shared.textureManager().addTextureId(b, "texture", true);
b.recycle();
_texture = new TextureVo("texture");
_object.textures().add(_texture);
_counter = 0;
}
@Override
public void updateScene()
{
_object.rotation().y = (float)(Math.sin(_counter*0.02f) * 45);
if (_counter % 40 == 0)
{
_texture.repeatU = ! _texture.repeatU;
}
if (_counter % 80 == 0)
{
_texture.repeatV = ! _texture.repeatV;
}
_counter++;
}
}
|
apache-2.0
|
Sage-ERP-X3/izpack
|
src/lib/com/izforge/izpack/panels/HTMLLicenceParamPanel.java
|
4179
|
package com.izforge.izpack.panels;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;
import javax.swing.ButtonGroup;
import javax.swing.JEditorPane;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import com.izforge.izpack.gui.IzPanelLayout;
import com.izforge.izpack.gui.LabelFactory;
import com.izforge.izpack.installer.InstallData;
import com.izforge.izpack.installer.InstallerFrame;
import com.izforge.izpack.installer.IzPanel;
import com.izforge.izpack.installer.ResourceManager;
public class HTMLLicenceParamPanel extends IzPanel implements ActionListener, HyperlinkListener
{
/**
* The text area.
*/
private JEditorPane textArea;
/**
* The radio buttons.
*/
private JRadioButton yesRadio;
private JRadioButton noRadio;
public static final String strLicenceId = "licenceid";
/**
* The constructor.
*
* @param idata The installation data.
* @param parent Description of the Parameter
*/
public HTMLLicenceParamPanel(InstallerFrame parent, InstallData idata)
{
super(parent, idata, new IzPanelLayout());
// We load the licence
loadLicence(idata);
// We put our components
add(LabelFactory.create(parent.langpack.getString("LicencePanel.info"),
parent.icons.getImageIcon("history"), LEADING), NEXT_LINE);
try
{
textArea = new JEditorPane();
textArea.setEditable(false);
textArea.addHyperlinkListener(this);
JScrollPane scroller = new JScrollPane(textArea);
textArea.setPage(loadLicence(idata));
add(scroller, NEXT_LINE);
}
catch (Exception err)
{
err.printStackTrace();
}
ButtonGroup group = new ButtonGroup();
yesRadio = new JRadioButton(parent.langpack.getString("LicencePanel.agree"), false);
group.add(yesRadio);
add(yesRadio, NEXT_LINE);
yesRadio.addActionListener(this);
noRadio = new JRadioButton(parent.langpack.getString("LicencePanel.notagree"), true);
group.add(noRadio);
add(noRadio, NEXT_LINE);
noRadio.addActionListener(this);
setInitialFocus(textArea);
getLayoutHelper().completeLayout();
}
/**
* Loads the license text.
*
* @return The license text URL.
*/
private URL loadLicence(InstallData idata)
{
String resNamePrifix = idata.getVariable(strLicenceId);
try
{
return ResourceManager.getInstance().getURL(resNamePrifix);
}
catch (Exception ex)
{
ex.printStackTrace();
}
return null;
}
/**
* Actions-handling method (here it launches the installation).
*
* @param e The event.
*/
public void actionPerformed(ActionEvent e)
{
if (yesRadio.isSelected())
{
parent.unlockNextButton();
}
else
{
parent.lockNextButton();
}
}
/**
* Indicates wether the panel has been validated or not.
*
* @return true if the user agrees with the license, false otherwise.
*/
public boolean isValidated()
{
if (noRadio.isSelected())
{
parent.exit();
return false;
}
return (yesRadio.isSelected());
}
/**
* Hyperlink events handler.
*
* @param e The event.
*/
public void hyperlinkUpdate(HyperlinkEvent e)
{
try
{
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED)
{
textArea.setPage(e.getURL());
}
}
catch (Exception err)
{
// TODO: Extend exception handling.
}
}
/**
* Called when the panel becomes active.
*/
public void panelActivate()
{
if (!yesRadio.isSelected())
{
parent.lockNextButton();
}
}
}
|
apache-2.0
|
IAMTJW/TJWspringMVC
|
src/main/java/com/tianjunwei/validator/MethodValidateController.java
|
2014
|
package com.tianjunwei.validator;
import java.util.HashMap;
import java.util.Map;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.tianjunwei.validator.service.ValidatorTestService;
@Controller
public class MethodValidateController {
@Autowired
ValidatorTestService validatorTestService;
@RequestMapping(value="/method", method = {RequestMethod.GET})
public String method(){
return "method";
}
@RequestMapping(value="/methodsave")
public String test5(String name, String password, Model model){
try {
String content = validatorTestService.getContent(name, password);
model.addAttribute("name", content);
} catch (ConstraintViolationException e) {
System.err.println(e);
addErrorMessage(model, e);
}
return "method";
}
protected void addErrorMessage(Model model, ConstraintViolationException e){
Map<String, String> errorMsg = new HashMap<String,String>();
model.addAttribute("errorMsg", errorMsg);
for (ConstraintViolation<?> constraintViolation : e.getConstraintViolations()) {
// 获得验证失败的类 constraintViolation.getLeafBean()
// 获得验证失败的值 constraintViolation.getInvalidValue()
// 获取参数值 constraintViolation.getExecutableParameters()
// 获得返回值 constraintViolation.getExecutableReturnValue()
errorMsg.put(constraintViolation.getLeafBean().getClass().getName() + "-" + constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage());
}
}
}
|
apache-2.0
|
jtgeiger/grison
|
lib/src/main/java/com/sibilantsolutions/grison/rx/event/result/AudioVideoLoginSendResult.java
|
469
|
package com.sibilantsolutions.grison.rx.event.result;
public class AudioVideoLoginSendResult extends AbstractResult {
public static final AudioVideoLoginSendResult IN_FLIGHT = new AudioVideoLoginSendResult(null);
public static final AudioVideoLoginSendResult SENT = new AudioVideoLoginSendResult(null);
public final Throwable failureCause;
public AudioVideoLoginSendResult(Throwable failureCause) {
this.failureCause = failureCause;
}
}
|
apache-2.0
|
changweihua/NTTemplate
|
Code/NTTemplate/Lance.ExFramework/Swagger/Attributes/SwaggerFileUploadAttribute.cs
|
530
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace Lance.ExFramework.Swagger.Attributes
{
/// <summary>
/// 标记Form表单内是否存在input:file
/// </summary>
[AttributeUsage(AttributeTargets.Parameter)]
public class SwaggerFileUploadAttribute : Attribute
{
public bool Required { get; private set; }
public SwaggerFileUploadAttribute(bool Required = true)
{
this.Required = Required;
}
}
}
|
apache-2.0
|
YAFNET/YAFNET
|
yafsrc/YAF.Types/Objects/UserRequestData.cs
|
1320
|
/* Yet Another Forum.NET
* Copyright (C) 2003-2005 Bjørnar Henden
* Copyright (C) 2006-2013 Jaben Cargman
* Copyright (C) 2014-2022 Ingo Herbote
* https://www.yetanotherforum.net/
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* https://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
namespace YAF.Types.Objects
{
using System;
public class UserRequestData
{
public bool DontTrack { get; set; }
public string UserAgent { get; set; }
public bool IsSearchEngine { get; set; }
public string Browser { get; set; }
public string Platform { get; set; }
}
}
|
apache-2.0
|
deltajs/version-a
|
deltaJS/com/validation/Validation.js
|
151
|
Validation.super = "delta.com.ObjectBase";
function Validation(){
}
Validation.properties = {
validate : function validate(value){
}
}
|
apache-2.0
|
sonu283304/onos
|
utils/misc/src/main/java/org/onlab/util/UnmodifiableDeque.java
|
5810
|
/*
* Copyright 2016 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onlab.util;
import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
import com.google.common.collect.Iterators;
/**
* Unmodifiable view of the specified Deque.
*/
public class UnmodifiableDeque<E> implements Deque<E> {
private final Deque<E> deque;
UnmodifiableDeque(Deque<E> deque) {
this.deque = checkNotNull(deque);
}
/**
* Returns an unmodifiable view of the specified Deque.
*
* @param <T> type
* @param deque underlying {@link Deque} to use.
* @return unmodifiable view of {@code deque}
*/
public static <T> Deque<T> unmodifiableDeque(Deque<T> deque) {
return new UnmodifiableDeque<T>(deque);
}
@Override
public void forEach(Consumer<? super E> action) {
deque.forEach(action);
}
@Override
public void addFirst(E e) {
throw new UnsupportedOperationException();
}
@Override
public boolean isEmpty() {
return deque.isEmpty();
}
@Override
public void addLast(E e) {
throw new UnsupportedOperationException();
}
@Override
public Object[] toArray() {
return deque.toArray();
}
@Override
public boolean offerFirst(E e) {
throw new UnsupportedOperationException();
}
@Override
public <T> T[] toArray(T[] a) {
return deque.toArray(a);
}
@Override
public boolean offerLast(E e) {
throw new UnsupportedOperationException();
}
@Override
public E removeFirst() {
throw new UnsupportedOperationException();
}
@Override
public E removeLast() {
throw new UnsupportedOperationException();
}
@Override
public E pollFirst() {
throw new UnsupportedOperationException();
}
@Override
public E pollLast() {
throw new UnsupportedOperationException();
}
@Override
public E getFirst() {
return deque.getFirst();
}
@Override
public E getLast() {
return deque.getLast();
}
@Override
public E peekFirst() {
return deque.peekFirst();
}
@Override
public E peekLast() {
return deque.peekLast();
}
@Override
public boolean removeFirstOccurrence(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeLastOccurrence(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
return deque.containsAll(c);
}
@Override
public boolean add(E e) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean offer(E e) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public E remove() {
throw new UnsupportedOperationException();
}
@Override
public E poll() {
throw new UnsupportedOperationException();
}
@Override
public E element() {
return deque.element();
}
@Override
public boolean removeIf(Predicate<? super E> filter) {
throw new UnsupportedOperationException();
}
@Override
public E peek() {
return deque.peek();
}
@Override
public void push(E e) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public E pop() {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public boolean equals(Object o) {
return deque.equals(o);
}
@Override
public boolean contains(Object o) {
return deque.contains(o);
}
@Override
public int size() {
return deque.size();
}
@Override
public Iterator<E> iterator() {
return Iterators.unmodifiableIterator(deque.iterator());
}
@Override
public Iterator<E> descendingIterator() {
return Iterators.unmodifiableIterator(deque.descendingIterator());
}
@Override
public int hashCode() {
return deque.hashCode();
}
@Override
public Spliterator<E> spliterator() {
return deque.spliterator();
}
@Override
public Stream<E> stream() {
return deque.stream();
}
@Override
public Stream<E> parallelStream() {
return deque.parallelStream();
}
@Override
public String toString() {
return deque.toString();
}
}
|
apache-2.0
|
samlanh/installment
|
application/modules/project/forms/FrmImport.php
|
1015
|
<?php
class Project_Form_FrmImport extends Zend_Dojo_Form
{
protected $tr;
protected $filter;
public function init()
{
$this->tr=Application_Form_FrmLanguages::getCurrentlanguage();
$this->filter = 'dijit.form.FilteringSelect';
}
function FrmImport($data){
$request=Zend_Controller_Front::getInstance()->getRequest();
$typeItems = empty($typeItems)?1:$typeItems;
$_dbgb = new Application_Model_DbTable_DbGlobal();
$branch_id = new Zend_Dojo_Form_Element_FilteringSelect('branch_id');
$branch_id->setAttribs(array(
'dojoType'=>'dijit.form.FilteringSelect',
'class'=>'fullside',
'required' =>'true',
'autoComplete'=>'false',
'queryExpr'=>'*${0}*',
));
$options_branch = $_dbgb->getAllBranchName(null,1);
$branch_id->setMultiOptions($options_branch);
if(!empty($data)){
$branch_id->setValue($data["branch_id"]);
}
$this->addElements(array(
$branch_id,
));
return $this;
}
}
|
apache-2.0
|
brycenrogers/linken
|
config/mail.php
|
4411
|
<?php
return [
/*
|--------------------------------------------------------------------------
| Mail Driver
|--------------------------------------------------------------------------
|
| Laravel supports both SMTP and PHP's "mail" function as drivers for the
| sending of e-mail. You may specify which one you're using throughout
| your application here. By default, Laravel is setup for SMTP mail.
|
| Supported: "smtp", "mail", "sendmail", "mailgun", "mandrill", "ses", "log"
|
*/
'driver' => env('MAIL_DRIVER', 'mandrill'),
/*
|--------------------------------------------------------------------------
| SMTP Host Address
|--------------------------------------------------------------------------
|
| Here you may provide the host address of the SMTP server used by your
| applications. A default option is provided that is compatible with
| the Mailgun mail service which will provide reliable deliveries.
|
*/
'host' => env('MAIL_HOST', 'smtp.mandrillapp.com'),
/*
|--------------------------------------------------------------------------
| SMTP Host Port
|--------------------------------------------------------------------------
|
| This is the SMTP port used by your application to deliver e-mails to
| users of the application. Like the host we have set this value to
| stay compatible with the Mailgun e-mail application by default.
|
*/
'port' => env('MAIL_PORT', 587),
/*
|--------------------------------------------------------------------------
| Global "From" Address
|--------------------------------------------------------------------------
|
| You may wish for all e-mails sent by your application to be sent from
| the same address. Here, you may specify a name and address that is
| used globally for all e-mails that are sent by your application.
|
*/
'from' => ['address' => null, 'name' => null],
/*
|--------------------------------------------------------------------------
| E-Mail Encryption Protocol
|--------------------------------------------------------------------------
|
| Here you may specify the encryption protocol that should be used when
| the application send e-mail messages. A sensible default using the
| transport layer security protocol should provide great security.
|
*/
'encryption' => env('MAIL_ENCRYPTION', 'tls'),
/*
|--------------------------------------------------------------------------
| SMTP Server Username
|--------------------------------------------------------------------------
|
| If your SMTP server requires a username for authentication, you should
| set it here. This will get used to authenticate with your server on
| connection. You may also set the "password" value below this one.
|
*/
'username' => env('MAIL_USERNAME'),
/*
|--------------------------------------------------------------------------
| SMTP Server Password
|--------------------------------------------------------------------------
|
| Here you may set the password required by your SMTP server to send out
| messages from your application. This will be given to the server on
| connection so that the application will be able to send messages.
|
*/
'password' => env('MAIL_PASSWORD'),
/*
|--------------------------------------------------------------------------
| Sendmail System Path
|--------------------------------------------------------------------------
|
| When using the "sendmail" driver to send e-mails, we will need to know
| the path to where Sendmail lives on this server. A default path has
| been provided here, which will work well on most of your systems.
|
*/
'sendmail' => '/usr/sbin/sendmail -bs',
/*
|--------------------------------------------------------------------------
| Mail "Pretend"
|--------------------------------------------------------------------------
|
| When this option is enabled, e-mail will not actually be sent over the
| web and will instead be written to your application's logs files so
| you may inspect the message. This is great for local development.
|
*/
'pretend' => false,
];
|
apache-2.0
|
pangeneral/DSEP
|
publicity/feedback/FeedbackResponseController.java
|
13957
|
package com.dsep.controller.publicity.feedback;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import com.dsep.domain.AttachmentHelper;
import com.dsep.domain.dsepmeta.feedback.FeedbackMessage;
import com.dsep.entity.User;
import com.dsep.entity.dsepmeta.FeedbackManagement;
import com.dsep.entity.dsepmeta.FeedbackResponse;
import com.dsep.entity.enumeration.AttachmentType;
import com.dsep.entity.enumeration.EnumModule;
import com.dsep.entity.enumeration.feedback.FeedbackResponseStatus;
import com.dsep.service.base.AttachmentService;
import com.dsep.service.base.DisciplineService;
import com.dsep.service.base.UnitService;
import com.dsep.service.dsepmeta.dsepmetas.DMBackupService;
import com.dsep.service.dsepmeta.dsepmetas.DMCheckLogicRuleService;
import com.dsep.service.dsepmeta.dsepmetas.DMCollectService;
import com.dsep.service.dsepmeta.dsepmetas.DMViewConfigService;
import com.dsep.service.publicity.feedback.FeedbackManagementService;
import com.dsep.service.publicity.feedback.FeedbackResponseService;
import com.dsep.service.publicity.process.production.feedback.FeedbackProcess;
import com.dsep.util.FileOperate;
import com.dsep.util.JsonConvertor;
import com.dsep.util.MySessionContext;
import com.dsep.util.UserSession;
@Controller
@RequestMapping("feedback")
public class FeedbackResponseController extends FeedbackController{
@Resource(name="feedbackManagementService")
private FeedbackManagementService feedbackManagementService;
@Resource(name="feedbackResponseService")
private FeedbackResponseService feedbackResponseService;
@Resource(name="backupService")
private DMBackupService backupService;
@Resource(name="collectService")
private DMCollectService collectService;
@Resource(name="dmViewConfigService")
private DMViewConfigService dmViewConfigService;
@Resource(name="disciplineService")
private DisciplineService disciplineService;
@Resource(name="unitService")
private UnitService unitService;
@Resource(name = "attachmentService")
private AttachmentService attachmentService;
@Resource(name = "checkLogicRule")
private DMCheckLogicRuleService checkLogicRule;
/**
* 进入反馈答复页面
* @param model
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
@RequestMapping("feedResponse")
public String beginFeedback(Model model,HttpSession session) throws IllegalArgumentException, IllegalAccessException{
UserSession userSession = new UserSession(session);
User user = userSession.getCurrentUser();
//获取异议处理类
FeedbackProcess process = userSession.getDsepProcessFactory().getFeedbackProcess();
String result = JsonConvertor.obj2JSON(feedbackManagementService.getFeedbackTypeTree());
Map<String,String> feedbackRoundMap = feedbackManagementService.getAllFeedbackRound();
Map<String,String> joinDiscMap = process.getDiscMap(disciplineService);
Map<String,String> joinUnitMap = process.getUnitMap(unitService);
Map<String,String> statusMap = process.getResponseStatusMap();
EnumModule module = new FeedbackResponseStatus();
model.addAttribute("responseStatusMap",JsonConvertor.mapJSON(module.getEnumMap()));
model.addAttribute("joinDisciplineMap", joinDiscMap);
model.addAttribute("joinUnitMap", joinUnitMap);
model.addAttribute("treeNodes", result);
model.addAttribute("feedbackRoundMap", feedbackRoundMap);
model.addAttribute("statusMap", statusMap);
model.addAttribute("user",user);
return "PublicAndFeedback/FeedBack/unit_feedback_gather";
}
@RequestMapping("feedResponse_getResponse")
@ResponseBody
public String getFeedbackResponse(HttpServletRequest request,
HttpServletResponse response, HttpSession session) throws IllegalArgumentException, IllegalAccessException{
return super.getFeedbackVM(request, response, session, feedbackResponseService);
}
/**
* 对某条采集项可能会有多条反馈数据，此函数返回所有的反馈数据集合
* @param request
* @param response
* @param session
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
@RequestMapping("feedResponse_getSameResponse")
@ResponseBody
public String getSameResponse(HttpServletRequest request,
HttpServletResponse response, HttpSession session) throws IllegalArgumentException, IllegalAccessException{
return super.getSameResponse(request, response, session, feedbackResponseService);
}
/**
* 获取本地数据配置信息
*/
@RequestMapping("feedResponse_getViewConfig")
@ResponseBody
public String getCollectDataConfig(@RequestParam(value = "entityId") String entityId) {
return super.getCollectDataConfig(dmViewConfigService, entityId);
}
/**
* 获取反馈项对应的采集项数据
* @return
*/
@RequestMapping("feedResponse_getCollectData")
@ResponseBody
public String pubDataDetail(HttpServletRequest request,
HttpServletResponse response,String entityId,String backupVersionId){
/*List<String> itemIds = new ArrayList<String>();
itemIds.addAll(Arrays.asList(request.getParameter("itemIds")));*/
List<String> itemArray = Arrays.asList(request.getParameter("itemIds"));
List<String> itemIds = Arrays.asList(itemArray.get(0).split(","));
if( itemIds.size() == 0 || itemIds.get(0) == null){
String itemId = request.getParameter("itemId");
itemIds.add(itemId);
}
return super.pubDataDetail(request, response, entityId, itemIds, backupVersionId,backupService, collectService);
}
/**
* 获取反馈批次信息
* @param request
* @param response
* @return
*/
@RequestMapping("feedResponse_getFeedbackRoundMessage")
@ResponseBody
public String getFeedbackRoundMessage(HttpServletRequest request,
HttpServletResponse response){
String feedbackRoundId = request.getParameter("feedback_round_id");
FeedbackMessage theMessage = feedbackManagementService.getFeedbackRoundMessage(feedbackRoundId);
return JsonConvertor.obj2JSON(theMessage);
}
/**
* 获取某条反馈答复
* @param request
* @param response
* @return
*/
@RequestMapping("feedResponse_getCertainResponse")
@ResponseBody
public String getFeedbackResponse(HttpServletRequest request,
HttpServletResponse response){
String responseId = request.getParameter("responseItemId");
FeedbackResponse feedbackResponse = feedbackResponseService.getResponseById(responseId);
return JsonConvertor.obj2JSON(feedbackResponse);
}
/**
* 单位填写完反馈答复的修改意见后进行逻辑检查
* @param request
* @param response
* @return
*/
@RequestMapping("feedResponse_logicCheck")
@ResponseBody
public String responseLogicCheck(HttpServletRequest request,
HttpServletResponse response){
String entityId = request.getParameter("entityId");
String attrName = request.getParameter("attrId");
String attrValue = request.getParameter("attrValue");
return checkLogicRule.checkSingleField(entityId, attrName, attrValue);
}
/**
* 对于同一条数据项如果有多条反馈
* @param request
* @param response
* @return
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
@RequestMapping("feedResponse_saveDeleteResponse")
@ResponseBody
public boolean saveDeleteResponse(HttpServletRequest request,
HttpServletResponse response) throws IllegalArgumentException, IllegalAccessException{
String feedbackRoundId = request.getParameter("feedbackRoundId");
String problemEntityItemId = request.getParameter("problemEntityItemId");
String responseItemId = request.getParameter("responseItemId");
String responseType = request.getParameter("responseType");
String adviceValue = request.getParameter("adviceValue");
String responseAdvice = request.getParameter("responseAdvice");
return feedbackResponseService.saveDeleteResponse(problemEntityItemId,responseItemId,responseType,adviceValue,responseAdvice,feedbackRoundId);
}
/**
* 保存反馈答复
* @param request
* @param response
* @return
*/
@RequestMapping("feedResponse_saveResponse")
@ResponseBody
public boolean saveResponse(HttpServletRequest request,
HttpServletResponse response){
String responseItemId = request.getParameter("responseItemId");
String responseType = request.getParameter("responseType");
String adviceValue = request.getParameter("adviceValue");
String responseAdvice = request.getParameter("responseAdvice");
return feedbackResponseService.saveResponse(responseItemId,responseType,adviceValue,responseAdvice);
}
/**
* 提交所有的反馈答复
* @param request
* @return
*/
@RequestMapping("feedResponse_submitResponse")
@ResponseBody
public boolean submitFeedbackResponse(HttpServletRequest request,
HttpServletResponse response){
String unitId = request.getParameter("unitId");
String feedbackType = request.getParameter("feedbackType");
String feedbackRoundId = request.getParameter("feedbackRoundId");
return feedbackResponseService.submitResponse(unitId,feedbackType,feedbackRoundId);
}
/**
* 是否所有的反馈项均给出了答复意见
* @param request
* @return
*/
@RequestMapping("feedResponse_isAllAdvice")
@ResponseBody
public boolean isAllAdvice(HttpServletRequest request,
HttpServletResponse response){
String unitId = request.getParameter("unitId");
String feedbackRoundId = request.getParameter("feedbackRoundId");
String feedbackType = request.getParameter("feedbackType");
return feedbackResponseService.isAllAdvice(unitId, feedbackType, feedbackRoundId);
}
@RequestMapping("feedResponse_isAllProfMaterial")
@ResponseBody
public boolean isAllProfMaterial(HttpServletRequest request,
HttpServletResponse response){
String unitId = request.getParameter("unitId");
String feedbackRoundId = request.getParameter("feedbackRoundId");
String feedbackType = request.getParameter("feedbackType");
return feedbackResponseService.isAllProfMaterial(unitId,feedbackType,feedbackRoundId);
}
/**
* 证明材料上传成功后将证明材料的ID保存到相应的反馈项中
* @param request
* @param response
* @return
*/
@RequestMapping("feedResponse_saveProveMaterial")
@ResponseBody
public boolean saveProveMaterial(HttpServletRequest request,
HttpServletResponse response){
String responseItemId = request.getParameter("responseItemId");
String proveMaterialId = request.getParameter("proveMaterialId");
return feedbackResponseService.uploadFile(responseItemId, proveMaterialId);
}
/**
* 学校提交反馈后查看具体的反馈意见
* @param request
* @param reponse
* @return
*/
@RequestMapping("feedResponse_queryAdviceDetail")
@ResponseBody
public String queryAdviceDetail(HttpServletRequest request,HttpServletResponse reponse){
String responseItemId = request.getParameter("responseItemId");
return feedbackResponseService.getFeedbackAdvice(responseItemId);
}
/**
* 上传证明材料
* @param file
* @return
*/
@RequestMapping("feedResponse_uploadFile")
@ResponseBody
public String uploadAttachment(HttpServletRequest request, String jsessionid){
MySessionContext myc= MySessionContext.getInstance();
HttpSession session = myc.getSession(jsessionid);
UserSession userSession = new UserSession(session);
User user = userSession.getCurrentUser();
MultipartFile file = FileOperate.getFile(request);
AttachmentHelper ah = attachmentService.getAttachmentHelper(file, user.getId(), AttachmentType.FEEDBACK, user.getUnitId());
if(FileOperate.upload(file, ah.getPath(), ah.getStorageName())){
return attachmentService.addAttachment(ah.getAttachment());
}
else{
return null;
}
}
/**
* 获取证明材料的下载路径
* @param id
* @return
*/
@RequestMapping("feedResponse_getDownloadPath")
@ResponseBody
public String downloadAttachment(String proveMaterialId){
String json = JsonConvertor.obj2JSON(attachmentService.getAttachmentPath(proveMaterialId));
return json;
}
/**
* 删除附件
* @param id
* @return
*/
@RequestMapping("feedResponse_fileDelete")
@ResponseBody
public boolean deleteAttachment(String attachmentId, String responseItemId){
boolean result = false;
try{
String path = attachmentService.getAttachmentPath(attachmentId);
result = feedbackResponseService.deleteProveMaterial(responseItemId,attachmentId);
FileOperate.delete(path);
}catch(Exception e){
return false;
}
return result;
}
/**
* 下载修改的数据
* @param request
* @param response
* @param session
* @return
*/
@RequestMapping("feedResponse_downloadFeedbackResponse")
@ResponseBody
public String unitdespResponse_downloadFeedbackResponse(
HttpServletRequest request, HttpServletResponse response,
HttpSession session){
String realPath = request.getSession().getServletContext().getRealPath("/");
String currentRoundId = request.getParameter("currenFeedbackRoundId");
String feedbackType = request.getParameter("feedbackType");
String feedbackStatus = request.getParameter("feedbackStatus");
FeedbackResponse feedbackResponse = new FeedbackResponse();
feedbackResponse.setFeedbackRoundId(currentRoundId);
feedbackResponse.setFeedbackType(feedbackType);
feedbackResponse.setFeedbackStatus(feedbackStatus);
return feedbackResponseService.unitdespResponse_downloadFeedbackResponse(feedbackResponse,realPath);
}
}
|
apache-2.0
|
PkayJava/MBaaS
|
mbaas-plain/src/main/java/com/angkorteam/mbaas/plain/request/collection/CollectionCreateRequest.java
|
2738
|
package com.angkorteam.mbaas.plain.request.collection;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
import java.util.ArrayList;
import java.util.List;
/**
* Created by Khauv Socheat on 2/12/2016.
*/
public class CollectionCreateRequest {
@Expose
@SerializedName("collectionName")
private String collectionName;
@Expose
@SerializedName("attributes")
private List<Attribute> attributes = new ArrayList<>();
public String getCollectionName() {
return collectionName;
}
public void setCollectionName(String collectionName) {
this.collectionName = collectionName;
}
public List<Attribute> getAttributes() {
return attributes;
}
public void setAttributes(List<Attribute> attributes) {
this.attributes = attributes;
}
public static class Attribute {
@Expose
@SerializedName("name")
private String name;
@Expose
@SerializedName("nullable")
private boolean nullable = true;
@Expose
@SerializedName("length")
private int length;
@Expose
@SerializedName("precision")
private int precision;
@Expose
@SerializedName("type")
private String type;
@Expose
@SerializedName("order")
private int order;
@Expose
@SerializedName("index")
private String index;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isNullable() {
return nullable;
}
public void setNullable(boolean nullable) {
this.nullable = nullable;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getPrecision() {
return precision;
}
public void setPrecision(int precision) {
this.precision = precision;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getOrder() {
return order;
}
public void setOrder(int order) {
this.order = order;
}
public String getIndex() {
return index;
}
public void setIndex(String index) {
this.index = index;
}
}
}
|
apache-2.0
|
MI-LA01/knife-ovh-cloud
|
lib/chef/knife/ovh_cloud_datastore_list.rb
|
1939
|
# Copyright (C) 2012, SCM Ventures AB
# Author: Ian Delahorne <ian@scmventures.se>
#
# Permission to use, copy, modify, and/or distribute this software for
# any purpose with or without fee is hereby granted, provided that the
# above copyright notice and this permission notice appear in all
# copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
# AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
# DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
# OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE
require 'chef/knife'
require 'chef/knife/base_ovh_cloud_command'
def number_to_human_size(number)
number = number.to_f
storage_units_fmt = ["byte", "kB", "MB", "GB", "TB"]
base = 1024
if number.to_i < base
unit = storage_units_fmt[0]
else
max_exp = storage_units_fmt.size - 1
exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base
exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
number /= base ** exponent
unit = storage_units_fmt[exponent]
end
return sprintf("%0.2f %s", number, unit)
end
# Lists all known data stores in datacenter with sizes
class Chef::Knife::OvhCloudDatastoreList < Chef::Knife::BaseOvhCloudCommand
banner "knife ovh cloud datastore list"
get_common_options
def run
$stdout.sync = true
vim = get_vim_connection
dc = get_datacenter
dc.datastore.each do |store|
avail = number_to_human_size(store.summary[:freeSpace])
cap = number_to_human_size(store.summary[:capacity])
puts "#{ui.color("Datastore", :cyan)}: #{store.name} (#{avail} / #{cap})"
end
end
end
|
apache-2.0
|
achikin/testrail-jenkins-plugin
|
src/main/java/testrail/testrail/TestRailObjects/Project.java
|
1277
|
/**
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package testrail.testrail.TestRailObjects;
/**
* Created by Drew on 3/24/2014.
*/
public class Project {
private int _id;
private String _name;
public void setId(int id) {
_id = id;
}
public void setName(String name) {
_name = name.trim();
}
public int getId() {
return _id;
}
public String getName() {
return _name;
}
public String getStringId() { return Integer.toString(_id); }
}
|
apache-2.0
|
boundary/boundary-nagios-plugins
|
exec_proc.lua
|
2107
|
-- Copyright 2014 Boundary,Inc.
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-- Copyright 2014 Boundary,Inc.
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
ExecProc = {path,args}
function ExecProc:new()
local o = {}
setmetatable(o, self)
self.__index = self
return o
end
function ExecProc:setPath(path)
if type(path) ~= "string" then error("path is not a string type",2) end
self.path = path
end
function ExecProc:setArgs(args)
if type(args) ~= "table" then error("args is not a table type",2) end
self.args = args
end
function ExecProc:execute()
if self.path == nil then error("path has not been set",2) end
local command = self:getCommand()
local file = assert(io.popen(command, 'r'))
self.output = file:read('*all')
file:close()
end
function ExecProc:getCommand()
if type(self.path) == nil then error("path has not been set",2) end
local command = self.path
if (self.args)
then
for i,j in pairs(self.args)
do
command = command.." "..j
end
end
return command
end
function ExecProc:getOutput()
return self.output
end
|
apache-2.0
|
googleapis/nodejs-translate
|
samples/v3beta1/translate_batch_translate_document.js
|
2530
|
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
'use strict';
function main(
projectId = 'YOUR_PROJECT_ID',
location = 'us-central1',
inputUri = 'gs://cloud-samples-data/translation/async_invoices/*',
outputUri = 'gs://YOUR_PROJECT_ID/translation/BATCH_DOCUMENT_TRANSLATION_OUTPUT/'
) {
// [START translate_batch_translate_document]
/**
* TODO(developer): Uncomment these variables before running the sample.
*/
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const inputUri = 'path_to_your_files';
// const outputUri = 'path_to_your_output_bucket';
// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate').v3beta1;
// Instantiates a client
const translationClient = new TranslationServiceClient();
const documentInputConfig = {
gcsSource: {
inputUri: inputUri,
},
};
async function batchTranslateDocument() {
// Construct request
const request = {
parent: translationClient.locationPath(projectId, location),
documentInputConfig: documentInputConfig,
sourceLanguageCode: 'en-US',
targetLanguageCodes: ['sr-Latn'],
inputConfigs: [
{
gcsSource: {
inputUri: inputUri,
},
},
],
outputConfig: {
gcsDestination: {
outputUriPrefix: outputUri,
},
},
};
// Batch translate documents using a long-running operation.
// You can wait for now, or get results later.
const [operation] = await translationClient.batchTranslateDocument(request);
// Wait for operation to complete.
const [response] = await operation.promise();
console.log(`Total Pages: ${response.totalPages}`);
}
batchTranslateDocument();
// [END translate_batch_translate_document]
}
process.on('unhandledRejection', err => {
console.error(err.message);
process.exitCode = 1;
});
main(...process.argv.slice(2));
|
apache-2.0
|
SchafferWang0818/SchafferBaseLibrary
|
app/src/main/java/com/schaffer/base/common/recycler/OnRecyclerScrollListener.java
|
5998
|
package com.schaffer.base.common.recycler;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
/**
* Created by AndroidSchaffer on 2017/9/21.
*/
public abstract class OnRecyclerScrollListener extends RecyclerView.OnScrollListener {
private static final int STATE_NORMAL = 0;
private static final int STATE_REFRESH = 1;
private static final int STATE_LOAD_MORE = 2;
private static final int TYPE_LINEARMANAGER = 0;
private static final int TYPE_GRIDMANAGER = 1;
private static final int TYPE_STAGGEREDMANAGER = 2;
private static final int ORIENTATION_VERTICAL = 0;
private static final int ORIENTATION_HORIZONTAL = 1;
private int recyclerState = STATE_NORMAL;
private int recyclerOrientation = ORIENTATION_VERTICAL;
private int recyclerManagerType = TYPE_LINEARMANAGER;
private boolean scrollOrientation;
public void setRecyclerState(int recyclerState) {
this.recyclerState = recyclerState;
}
public void setRecyclerOrientation(int recyclerOrientation) {
this.recyclerOrientation = recyclerOrientation;
}
public void setRecyclerManagerType(int recyclerManagerType) {
this.recyclerManagerType = recyclerManagerType;
}
@Override
public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
super.onScrollStateChanged(recyclerView, newState);
if (newState == RecyclerView.SCROLL_STATE_IDLE) {
if (recyclerOrientation == ORIENTATION_VERTICAL) {
//vertical
if (recyclerManagerType == TYPE_LINEARMANAGER) {
if (isLinearBottom(recyclerView)) {
onLoadMore(recyclerView);
}
} else if (recyclerManagerType == TYPE_GRIDMANAGER) {
if (isGridBottom(recyclerView)) {
onLoadMore(recyclerView);
}
} else if (recyclerManagerType == TYPE_STAGGEREDMANAGER) {
if (isStaggeredBottom(recyclerView)) {
onLoadMore(recyclerView);
}
}
} else {
//horizontal
if (recyclerManagerType == TYPE_LINEARMANAGER) {
if (isLinearRight(recyclerView)) {
onLoadMore(recyclerView);
}
} else if (recyclerManagerType == TYPE_GRIDMANAGER) {
if (isGridRight(recyclerView)) {
onLoadMore(recyclerView);
}
} else if (recyclerManagerType == TYPE_STAGGEREDMANAGER) {
onLoadMore(recyclerView);
}
}
}
}
abstract void onLoadMore(RecyclerView recyclerView);
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
scrollOrientation = dy > 0;
}
public boolean isLinearBottom(RecyclerView recyclerView) {
LinearLayoutManager layoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();
int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
int visibleItemCount = layoutManager.getChildCount();
int totalItemCount = layoutManager.getItemCount();
return scrollOrientation&&visibleItemCount > 0 && lastVisibleItemPosition == totalItemCount - 1 && !recyclerView.canScrollVertically(1);
}
public boolean isLinearRight(RecyclerView recyclerView) {
LinearLayoutManager layoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();
int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
int visibleItemCount = layoutManager.getChildCount();
int totalItemCount = layoutManager.getItemCount();
return scrollOrientation&&visibleItemCount > 0 && lastVisibleItemPosition == totalItemCount - 1 && !recyclerView.canScrollHorizontally(1);
}
public boolean isGridBottom(RecyclerView recyclerView) {
GridLayoutManager layoutManager = (GridLayoutManager) recyclerView.getLayoutManager();
int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
int visibleItemCount = layoutManager.getChildCount();
int totalItemCount = layoutManager.getItemCount();
return scrollOrientation&&visibleItemCount > 0 && lastVisibleItemPosition == totalItemCount - 1 && !recyclerView.canScrollVertically(1);
}
public boolean isGridRight(RecyclerView recyclerView) {
GridLayoutManager layoutManager = (GridLayoutManager) recyclerView.getLayoutManager();
int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
int visibleItemCount = layoutManager.getChildCount();
int totalItemCount = layoutManager.getItemCount();
return scrollOrientation&&visibleItemCount > 0 && lastVisibleItemPosition == totalItemCount - 1 && !recyclerView.canScrollHorizontally(1);
}
public boolean isStaggeredBottom(RecyclerView recyclerView) {
StaggeredGridLayoutManager layoutManager = (StaggeredGridLayoutManager) recyclerView.getLayoutManager();
int lastVisibleItemPosition = getMaxElem(layoutManager.findLastCompletelyVisibleItemPositions(new int[layoutManager.getSpanCount()]));
int totalItemCount = layoutManager.getItemCount();
return scrollOrientation&&lastVisibleItemPosition == (totalItemCount - 1) && !recyclerView.canScrollVertically(1);
}
private int getMaxElem(int[] arr) {
int size = arr.length;
int maxVal = Integer.MIN_VALUE;
for (int i = 0; i < size; i++) {
if (arr[i] > maxVal) {
maxVal = arr[i];
}
}
return maxVal;
}
}
|
apache-2.0
|
non/squants
|
src/main/scala/squants/radio/RadiantIntensity.scala
|
2465
|
/* *\
** Squants **
** **
** Scala Quantities and Units of Measure Library and DSL **
** (c) 2013-2014, Gary Keorkunian **
** **
\* */
package squants.radio
import squants._
import squants.energy.Watts
import squants.space.{ SquareMeters, SquaredRadians }
/**
* @author garyKeorkunian
* @since 0.1
*
* @param value Double
*/
final class RadiantIntensity private (val value: Double) extends Quantity[RadiantIntensity] {
def valueUnit = RadiantIntensity.valueUnit
def *(that: SolidAngle): Power = Watts(toWattsPerSteradian * that.toSquaredRadians)
def /(that: Power): SolidAngle = SquareRadians(toWattsPerSteradian / that.toWatts)
def /(that: Length): SpectralIntensity = WattsPerSteradianPerMeter(toWattsPerSteradian / that.toMeters)
def /(that: SpectralIntensity): Length = Meters(toWattsPerSteradian / that.toWattsPerSteradianPerMeter)
def /(that: Area): Radiance = WattsPerSteradianPerSquareMeter(toWattsPerSteradian / that.toSquareMeters)
def /(that: Radiance): Area = SquareMeters(this.toWattsPerSteradian / that.toWattsPerSteradianPerSquareMeter)
def toWattsPerSteradian = to(WattsPerSteradian)
}
object RadiantIntensity extends QuantityCompanion[RadiantIntensity] {
private[radio] def apply[A](n: A)(implicit num: Numeric[A]) = new RadiantIntensity(num.toDouble(n))
def apply = parseString _
def name = "RadiantIntensity"
def valueUnit = WattsPerSteradian
def units = Set(WattsPerSteradian)
}
trait RadiantIntensityUnit extends UnitOfMeasure[RadiantIntensity] {
def apply[A](n: A)(implicit num: Numeric[A]) = RadiantIntensity(convertFrom(n))
}
object WattsPerSteradian extends RadiantIntensityUnit with ValueUnit {
val symbol = Watts.symbol + "/" + SquaredRadians.symbol
}
object RadiantIntensityConversions {
lazy val wattPerSteradian = WattsPerSteradian(1)
implicit class RadiantIntensityConversions[A](n: A)(implicit num: Numeric[A]) {
def wattsPerSteradian = WattsPerSteradian(n)
}
implicit object RadiantIntensityNumeric extends AbstractQuantityNumeric[RadiantIntensity](RadiantIntensity.valueUnit)
}
|
apache-2.0
|
garrapeta/jumplings
|
src/com/garrapeta/jumplings/game/actor/JumplingActor.java
|
8141
|
package com.garrapeta.jumplings.game.actor;
import android.graphics.Canvas;
import android.graphics.PointF;
import android.graphics.RectF;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.Contact;
import com.badlogic.gdx.physics.box2d.Filter;
import com.badlogic.gdx.physics.box2d.Manifold;
import com.badlogic.gdx.utils.Pool.Poolable;
import com.garrapeta.MathUtils;
import com.garrapeta.gameengine.Box2DActor;
import com.garrapeta.gameengine.utils.PhysicsUtils;
import com.garrapeta.jumplings.game.JumplingsWorld;
/**
* Clase base de los actores Jumplings
*
* @author GaRRaPeTa
*/
public abstract class JumplingActor<T extends JumplingsWorld> extends Box2DActor<T> implements Poolable {
// ----------------------------------------- Constantes
/**
* Radio base de los actores, en unidades del mundo.
*/
public final static float BASE_RADIUS = 0.6f;
private final static float OVERALL_ACTOR_RESTITUTION = 0.7f;
protected final static float AUX_BODIES_RESTITUTION = OVERALL_ACTOR_RESTITUTION;
private final static float BOUNCING_VEL = -20;
public final static int CONTACT_FILTER_BIT = 0x00001;
public final static Filter NO_CONTACT_FILTER;
public final static Filter CONTACT_FILTER;
// ----------------------------------------- Variables de instancia
public Body mMainBody;
/**
* Radio de la circunferencia circunscrita en el cuerpo del enemigo, en
* unidades del mundo.
*/
public float mRadius;
/**
* Si el enemigo ha llegado a entrar dentro de los bounds del juego. Si el
* enemigo nace fuera del mundo visible se considera que no se ha
* introducido del todo.
*/
protected boolean mEntered;
// --------------------------------------------------- Inicializaci�n
// est�tica
static {
NO_CONTACT_FILTER = new Filter();
NO_CONTACT_FILTER.categoryBits = 0;
NO_CONTACT_FILTER.maskBits = 0;
CONTACT_FILTER = new Filter();
CONTACT_FILTER.categoryBits = CONTACT_FILTER_BIT;
CONTACT_FILTER.maskBits = WallActor.WALL_FILTER_BIT | WallActor.FLOOR_FILTER_BIT | CONTACT_FILTER_BIT;
}
// --------------------------------------------------- Constructor
protected JumplingActor(T world, int zIndex) {
super(world, zIndex);
}
// ----------------------------------------- M�todos de Box2DActor
@Override
protected void onAddedToWorld() {
super.onAddedToWorld();
getWorld().onJumplingActorAdded(this);
mEntered = isInsideWorld();
}
@Override
protected void onRemovedFromWorld() {
super.onRemovedFromWorld();
getWorld().onJumplingActorRemoved(this);
free(getWorld().getFactory());
}
@Override
public final void onPreSolveContact(Body bodyA, Box2DActor<T> actorB, Body bodyB, Contact contact, Manifold oldManifold) {
if (actorB instanceof WallActor) {
WallActor wall = (WallActor) actorB;
if (!mEntered) {
// est� entrando se le deja pasar
contact.setEnabled(false);
} else if (wall.floor) {
// se va a escapar!
float v = bodyA.getLinearVelocity().y;
// si va muy r�pido hacia abajo se perdona al jugador y se deja
// que rebote
if (v > BOUNCING_VEL) {
// se deja que se escape
contact.setEnabled(false);
}
}
}
}
@Override
public void onBeginContact(Body thisBody, Box2DActor<T> other, Body otherBody, Contact contact) {
if (other instanceof WallActor) {
WallActor wall = (WallActor) other;
if (wall.security) {
getWorld().removeActor(this);
mEntered = false;
}
}
}
@Override
public void onEndContact(Body bodyA, Box2DActor<T> actorB, Body bodyB, Contact contact) {
if (actorB instanceof WallActor) {
WallActor wall = (WallActor) actorB;
if (!mEntered) {
// si ha acabado de entrar en pantalla se pone vulnerable
mEntered = true;
} else if (mEntered && wall.floor) {
if (!isInsideWorld()) {
// finalmente escapa
onScapedFromBounds();
}
}
}
}
@Override
public final void draw(Canvas canvas) {
if (getWorld().mDrawActorBitmaps) {
drawBitmaps(canvas);
}
if (getWorld().mWireframeMode || !getWorld().mDrawActorBitmaps) {
super.drawBodiesShapes(canvas);
}
}
@Override
protected void dispose() {
super.dispose();
mMainBody = null;
}
// ----------------------------------------------- Methods from Poolable
@Override
public final void reset() {
assertInnited();
setNotInitted();
}
// ------------------------------------------------ Métodos propios
public void init(PointF worldPos) {
initBodies(worldPos);
initPhysicProperties();
initBitmaps();
setInitted();
}
/**
* Crea los cuerpos y los elementos f�sicos
*
* @param worldPos
*/
protected abstract void initBodies(PointF worldPos);
/**
* Inicializa todo lo relativo a la f�sica
*/
private final void initPhysicProperties() {
// Para que el actor se comporte con una restituci�n global, se pone
// al cuerpo principal una restituci�n apropiada
// TODO: ¿que era esto??
double ratio = getMainMassRatio();
float mainBodyRestitution = (float) (OVERALL_ACTOR_RESTITUTION * (1 / ratio));
mMainBody.getFixtureList()
.get(0)
.setRestitution(mainBodyRestitution);
}
/**
* Initialises the bitmaps
*/
protected abstract void initBitmaps();
/**
* @return
*/
protected boolean isInsideWorld() {
PointF worldPos = this.getWorldPos();
RectF wr = getWorld().mViewport.getWorldBoundaries();
return MathUtils.isCircunferenceInRectangle(worldPos.x, worldPos.y, mRadius, wr.left, wr.bottom, wr.right, wr.top);
}
protected void onScapedFromBounds() {
getWorld().removeActor(this);
}
/**
* @return
*/
protected Body getMainBody() {
return mMainBody;
}
/**
* @return
*/
public double getMainMassRatio() {
double mainBodiesMass = 0;
Body mainBody = getMainBody();
mainBodiesMass = mainBody.getMass();
return mainBodiesMass / this.getMass();
}
/**
* @return
*/
public final PointF getWorldPos() {
Body mainBody = getMainBody();
Vector2 wc = mainBody.getWorldCenter();
return new PointF(wc.x, wc.y);
}
/**
* @param vx
* @param vy
*/
public final void setLinearVelocity(float vx, float vy) {
double ratio = getMainMassRatio();
getMainBody().setLinearVelocity((float) (vx * (1 / ratio)), (float) (vy * (1 / ratio)));
}
/**
* @param maxHeight
* @return
*/
public final double getInitialYVelocity(double maxHeight) {
double distance = maxHeight - getWorldPos().y;
return PhysicsUtils.getInitialVelocity(distance, 0, getWorld().getGravityY());
}
protected abstract void drawBitmaps(Canvas canvas);
/**
* To be implemented by extending classes to free this resource from its
* pool in the factory
*
* @param factory
*/
protected abstract void free(JumplingsFactory factory);
}
|
apache-2.0
|
evhub/coconut
|
coconut/command/__init__.py
|
778
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------------------------------------------------
# INFO:
# -----------------------------------------------------------------------------------------------------------------------
"""
Author: Evan Hubinger
License: Apache 2.0
Description: The Coconut command module.
"""
# -----------------------------------------------------------------------------------------------------------------------
# IMPORTS:
# -----------------------------------------------------------------------------------------------------------------------
from __future__ import print_function, absolute_import, unicode_literals, division
from coconut.command.command import * # NOQA
|
apache-2.0
|
neykov/incubator-brooklyn
|
software/database/src/test/java/brooklyn/entity/database/postgresql/PostgreSqlGceLiveTest.java
|
1878
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package brooklyn.entity.database.postgresql;
import org.testng.annotations.Test;
import brooklyn.entity.AbstractGoogleComputeLiveTest;
import brooklyn.entity.database.DatastoreMixins.DatastoreCommon;
import brooklyn.entity.database.VogellaExampleAccess;
import brooklyn.entity.proxying.EntitySpec;
import brooklyn.location.Location;
import com.google.common.collect.ImmutableList;
public class PostgreSqlGceLiveTest extends AbstractGoogleComputeLiveTest {
@Override
protected void doTest(Location loc) throws Exception {
PostgreSqlNode psql = app.createAndManageChild(EntitySpec.create(PostgreSqlNode.class)
.configure(DatastoreCommon.CREATION_SCRIPT_CONTENTS, PostgreSqlIntegrationTest.CREATION_SCRIPT));
app.start(ImmutableList.of(loc));
new VogellaExampleAccess("org.postgresql.Driver", psql.getAttribute(DatastoreCommon.DATASTORE_URL)).readModifyAndRevertDataBase();
}
@Test(enabled=false)
public void testDummy() { } // Convince testng IDE integration that this really does have test methods
}
|
apache-2.0
|
dritonshoshi/n-sysmon
|
n-sysmon-core/src/main/resources/nsysmon-res/js/ctrl-aggregated.js
|
22390
|
angular.module('NSysMonApp').controller('CtrlAggregated', function($scope, $log, Rest, escapeHtml, $timeout, $location) {
$('.button-segment').affix({
offset: {
top: 95
}
});
function reinitTooltips() {
$('.btn').tooltip({
container: 'body',
html: true
});
}
reinitTooltips();
$scope.$watch('isStarted', function() {
$('.btn').tooltip('hide');
$timeout(reinitTooltips, 0);
});
$('title').text("NSysmon - Aggregated Measurement");
$scope.expansionModel = {};
$scope.markedNodes = {};
$scope.rootLevel = 0;
$scope.hideTitleRows = 1;
$scope.showDataTooltips = 0;
$scope.hideSearchNonMatchingNodes = true;
$scope.expandSearchMatchingNodes = true;
$scope.loadDataForExportToRam = true;
/* Delayed Search - Start */
var timeoutPromise;
var searchDelayInMs = 500;
$scope.$watch('nodeSearchText', function (val) {
if ($scope.nodeSearchText){
$timeout.cancel(timeoutPromise);
}
var tempFilterText = val;
timeoutPromise = $timeout(function () {
$scope.nodeSearchText = tempFilterText;
//collapse all nodes when search is active
$scope.expansionModel = [];
renderTree();
}, searchDelayInMs); // delay
});
/* Delayed Search - End */
var nodesByFqn = {};
$scope.$watch('hideTitleRows', renderTree);
$scope.$watch('showDataTooltips', renderTree);
$scope.$watch('hideSearchNonMatchingNodes', renderTree);
function initFromResponse(data) {
// $log.log('init from response');
if ($scope.loadDataForExportToRam) {
$scope.data = angular.toJson(data);
}
$scope.isStarted = data.isStarted;
$scope.columnDefs = data.columnDefs.reverse();
$scope.traces = data.traces;
$scope.pickedTraces = $scope.traces; //TODO keep selection on 'refresh'
nodesByFqn = {};
$scope.markedNodes = {};
initTraceNodes($scope.traces, 0, '');
// $log.log('after init trace nodes');
$scope.totalDataWidth = 0;
for(var i=0; i<data.columnDefs.length; i++) {
var cw = data.columnDefs[i].width.toLowerCase();
if(cw === 'short') {
$scope.totalDataWidth += 40;
}
if(cw === 'medium') {
$scope.totalDataWidth += 60;
}
if(cw === 'long') {
$scope.totalDataWidth += 100;
}
}
renderTree();
// unblock GUI after process
blockGui(false);
}
// TODO : Analyse this why it computes so long. Firefox causes an Script error.
function initTraceNodes(nodes, level, prefix) {
if(nodes) {
for(var i=0; i<nodes.length; i++) {
nodes[i].level = level;
var fqn = prefix + '\n' + (nodes[i].id || nodes[i].name);
nodes[i].fqn = fqn;
nodesByFqn[fqn] = nodes[i];
initTraceNodes(nodes[i].children, level+1, fqn);
}
}
}
function sendCommand(cmd) {
// block gui for long calls
blockGui(true);
Rest.call(cmd, initFromResponse);
}
$scope.refresh = function() {
sendCommand('getData');
};
$scope.clear = function() {
$scope.expansionModel = {};
sendCommand('doClear');
};
$scope.start = function() {
sendCommand('doStart');
};
$scope.stop = function() {
sendCommand('doStop');
};
$scope.pickClass = function() {
return $scope.isInPickMode ? 'btn-danger' : 'btn-default';
};
//disabled getData on load due to performance problems with huge data
// $scope.refresh();
// check if data from other sources should be loaded
function loadExternalData() {
var loadFileParam = $location.search().loadfile;
if (loadFileParam) {
// block gui for long calls
blockGui(true);
Rest.callOther("loadableServerDataFiles", "loadFromFile" + "/" + loadFileParam, initFromResponse);
}
}
loadExternalData();
function revIdx(idx) {
return $scope.columnDefs.length - idx - 1;
}
$scope.revIdx = function(idx) {
return $scope.columnDefs.length - idx - 1;
};
var thousandsSeparator = 1234.5.toLocaleString().charAt(1);
var decimalSeparator = 1234.5.toLocaleString().charAt(5);
$scope.formatNumber = function(number, numFracDigits) {
var parts = number.toFixed(numFracDigits).toString().split('.');
parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSeparator);
return parts.join(decimalSeparator);
};
$scope.expandLongest = function() {
$scope.markedNodes = {};
function setExpandedMainLevel(nodes) {
// expand all top level-entries
if(nodes) {
for(var i=0; i<nodes.length; i++) {
$scope.expansionModel[nodes[i].fqn] = true;
setExpandedLongest(nodes[i].children);
}
}
}
function setExpandedLongest(nodes) {
//for all sub-entries only expand the longest call
if(nodes) {
var longestNode;
for(var i=0; i<nodes.length; i++) {
if (!longestNode || (longestNode.data[1] < nodes[i].data[1] && !nodes[i].isNotSerial)) {
longestNode = nodes[i];
}
}
$scope.expansionModel[longestNode.fqn] = true;
setExpandedLongest(longestNode.children);
if (!longestNode.children || longestNode.children.length == 0){
$scope.markedNodes[longestNode.fqn] = true;
}
}
}
setExpandedMainLevel($scope.traces);
renderTree();
};
$scope.expandAll = function() {
function setExpanded(nodes) {
if(nodes) {
for(var i=0; i<nodes.length; i++) {
$scope.expansionModel[nodes[i].fqn] = true;
setExpanded(nodes[i].children);
}
}
}
setExpanded($scope.traces);
renderTree();
};
$scope.collapseAll = function() {
$scope.expansionModel = {};
renderTree();
};
$scope.isPercentage = function(columnDef) {
return columnDef.isPercentage;
};
$scope.progressWidthStyle = function(value) {
return 'background-size: ' + (value + 2) + '% 100%';
};
$scope.colClass = function(idx) {
return 'column-' + $scope.columnDefs[idx].width.toLowerCase();
};
$scope.nodeIconClass = function(node) {
if(! node.fqn) {
//TODO remove this heuristic
node = nodesByFqn[node];
}
if(node.children && node.children.length) {
return $scope.isExpanded(node) ? 'node-icon-expanded' : 'node-icon-collapsed';
}
return 'node-icon-empty';
};
$scope.nodeIconClassWasKilled = function(node) {
//$log.log("xx="+node.wasKilled);
if(node && node.wasKilled) {
return 'node-icon-wasKilled';
}
return 'no-icon node-icon-empty';
};
$scope.nodeIconMarked = function(node) {
if(node && $scope.markedNodes[node.fqn]) {
return 'node-icon-marked';
}
return 'no-icon node-icon-empty';
};
$scope.nodeMarker = function(node) {
if(node && $scope.markedNodes[node.fqn]) {
return 'data-row-marked';
}
return '';
};
$scope.expansionStyle = function(node) {
return $scope.isExpanded(node) ? 'block' : 'none';
};
$scope.isExpanded = function(node) {
return $scope.expansionModel[node.fqn];
};
$scope.clickTreeNode = function(event, node) {
if($scope.isInPickMode) {
pickTreeNode(node);
}
else {
var clicked = $(event.target);
var dataRow = clicked.parents('.data-row');
toggleTreeNode(dataRow, node);
}
};
function toggleTreeNode(dataRow, node) {
var childrenDiv = dataRow.next();
if(childrenDiv.hasClass('unrendered')) {
childrenDiv.replaceWith(htmlForChildrenDiv(node, true));
childrenDiv = dataRow.next();
childrenDiv.find('.data-row.with-children').click(onClickNode);
}
childrenDiv.slideToggle(50, function() {
$scope.$apply(function() {
$scope.expansionModel[node.fqn] = !$scope.expansionModel[node.fqn];
var nodeIconDiv = dataRow.children('.node-icon');
if($scope.isExpanded(node)) {
nodeIconDiv.removeClass('node-icon-collapsed').addClass('node-icon-expanded');
}
else {
nodeIconDiv.addClass('node-icon-collapsed').removeClass('node-icon-expanded');
}
});
});
}
function pickTreeNode(node) {
$scope.$apply(function() {
$scope.pickedTraces = [node];
$scope.isInPickMode = false;
$scope.rootLevel = node.level;
});
renderTree();
}
$scope.togglePickMode = function() {
$scope.isInPickMode = ! $scope.isInPickMode;
};
$scope.unpick = function() {
$scope.pickedTraces = $scope.traces;
$scope.rootLevel = 0;
renderTree();
};
$scope.getJsonDownloadLink = function() {
return Rest.getDataUrl('getData');
};
$scope.getJsonFilename = function() {
return "nsysmon-export-" + getFormattedNow() + '.json';
};
$scope.doImportJSON = function() {
$scope.uploadFile();
};
$scope.doExportVisibleAsJSON = function() {
var blob = new Blob([$scope.data], {type: "application/json;charset=utf-8"});
saveAs(blob, "nsysmon-export-" + getFormattedNow() + '.json');
};
$scope.uploadFile = function(){
var file = document.getElementById('file').files[0], reader = new FileReader();
// block gui while uploading file
blockGui(true);
reader.onloadend = function(e){
$scope.$apply(function() {
initFromResponse(angular.fromJson(e.target.result));
});
};
reader.readAsBinaryString(file);
};
function blockGui(boolean){
var element = document.getElementById("blocker");
if (boolean) {
$scope.originClassName = element.className;
element.className+=" blocker";
}else{
element.classList.remove("blocker");
}
}
function pad2(n) {
var result = n.toString();
while(result.length < 2) {
result = '0' + result;
}
return result;
}
function getFormattedNow() {
var now = new Date();
return now.getFullYear() + '-' + pad2((now.getMonth() + 1)) + '-' + pad2(now.getDate()) + '-' + pad2(now.getHours()) + '-' + pad2(now.getMinutes()) + '-' + pad2(now.getSeconds());
}
$scope.doExportVisibleAsExcel = function() {
var data = 'Name\tLevel';
for(var i=0; i<$scope.columnDefs.length; i++) {
data += '\t' + $scope.columnDefs[revIdx(i)].name;
}
function append(node) {
var row = '\n';
row += ' '.substring(0, 2*(node.level - $scope.rootLevel));
row += node.name + '\t' + node.level;
for(var i=0; i < $scope.columnDefs.length; i++) {
row += '\t' + $scope.formatNumber(node.data[i], $scope.columnDefs[i].numFracDigits);
}
data += row;
for(var j=0; j<(node.children || []).length; j++) {
append(node.children[j]);
}
}
for(var j=0; j<$scope.pickedTraces.length; j++) {
append($scope.pickedTraces[j]);
}
var blob = new Blob([data], {type: "application/excel;charset=utf-8"});
saveAs(blob, "nsysmon-export-" + getFormattedNow() + '.xls');
};
function renderTree() {
var hhttmmll = htmlForAllTrees();
// it is an important performance optimization to explicitly unregister event listeners and remove old child
// elements from the DOM instead of implicitly removing them in the call to $(...).html(...) - the difference
// is seconds vs. minutes for large trees!
// $('.data-row.with-children').off();
var myNode = document.getElementById("theTree");
while (myNode && myNode.firstChild) {
myNode.removeChild(myNode.firstChild);
}
$('#theTree').html(hhttmmll);
$('.data-row.with-children').click(onClickNode);
if ($scope.showDataTooltips == 1){
$("[data-toggle=data-tooltip]").tooltip();
}
}
function onClickNode() {
var fqn = $(this).children('.fqn-holder').text();
if($scope.isInPickMode) {
pickTreeNode(nodesByFqn[fqn]);
}
else {
toggleTreeNode($(this), nodesByFqn[fqn]);
}
}
function htmlForAllTrees() {
var htmlForTableHeader = (function(){
var titles = '';
angular.forEach($scope.columnDefs, function(curCol, colIdx) {
titles += '<div class="' + $scope.colClass(colIdx) + '">' + curCol.name + '</div>';
});
return '' +
'<div class="table-header"> <div style="float:right;">' +
titles +
'</div></div>';
}());
var result = '';
if ($scope.hideTitleRows) {
result += '<div>' + htmlForTableHeader + '</div>';
angular.forEach($scope.pickedTraces, function(rootNode) {
if (shouldRenderNode(rootNode, $scope.nodeSearchText)){
result +=
'<div>' +
htmlForTreeNode(rootNode) +
'</div>';
}
});
}
else {
angular.forEach($scope.pickedTraces, function(rootNode) {
if (shouldRenderNode(rootNode, $scope.nodeSearchText)) {
result +=
'<div>' +
htmlForTableHeader +
htmlForTreeNode(rootNode) +
'</div>';
}
});
}
return result;
}
$scope.isValidSearchActive = function() {
return isValidSearchActive($scope.nodeSearchText);
};
$scope.clearSearch = function() {
$scope.nodeSearchText = undefined;
};
$scope.isSearchTooShort = function() {
return ($scope.nodeSearchText && $scope.nodeSearchText.length < 4);
};
function isValidSearchActive(stringToSearchFor) {
return !(!stringToSearchFor || stringToSearchFor.length < 4);
}
function nodeOrChildrenMatchSearch(curNode, stringToSearchFor) {
var display = false;
var search = stringToSearchFor.toLowerCase();
if (curNode.name.toLowerCase().indexOf(search) > -1) {
display = true;
return true;
}
//check tooltips
if (curNode && curNode.tooltip) {
curNode.tooltip.forEach(function(entry) {
if ((entry.id.toLowerCase().indexOf(search) > -1) || (entry.value.toLowerCase().indexOf(search) > -1)) {
display = true;
return true;
}
}, this);
}
angular.forEach(curNode.children, function(child) {
if (child.name.toLowerCase().indexOf(search) > -1) {
display = true;
return true;
}
//check tooltips
if (child && child.tooltip) {
child.tooltip.forEach(function(entry) {
if ((entry.id.toLowerCase().indexOf(search) > -1) || (entry.value.toLowerCase().indexOf(search) > -1)) {
display = true;
return true;
}
}, this);
}
display |= shouldRenderNode(child, stringToSearchFor);
if (display){
return true;
}
});
return display;
}
/*
Checks if this node should be displayed, used e.g. for the search-filter
*/
function shouldRenderNode(curNode, stringToSearchFor) {
if (!isValidSearchActive(stringToSearchFor)){
return true;
}
return nodeOrChildrenMatchSearch(curNode, stringToSearchFor);
}
function htmlForTreeNode(curNode) {
if (!shouldRenderNode(curNode, $scope.nodeSearchText) && $scope.hideSearchNonMatchingNodes){
return '';
}
if (isValidSearchActive($scope.nodeSearchText) && $scope.expandSearchMatchingNodes){
$scope.expansionModel[curNode.fqn] = true;
}
var dataRowSubdued = !curNode.isNotSerial ? '' : 'data-row-subdued';
var dataCols = '';
angular.forEach($scope.columnDefs, function(curCol, colIdx) {
dataCols += '<div class="' + $scope.colClass(colIdx) + '">';
var formattedValue = $scope.formatNumber(curNode.data[revIdx(colIdx)], $scope.columnDefs[colIdx].numFracDigits);
if(curCol.isPercentage) {
if(!curNode.isNotSerial)
dataCols += '<div class="aprogress-background"><div class="aprogress-bar" style="' + $scope.progressWidthStyle(curNode.data[revIdx(colIdx)]) + '">' + formattedValue + '</div></div>';
else
dataCols += '<div class="subdued-progress-background">' + formattedValue + '</div>';
}else if(curCol.isTimestamp) {
//console.log(new Date((new Date().getTime() + curNode.data[revIdx(colIdx)])).toLocaleTimeString());
var timeString = new Date((new Date().getTime() + curNode.data[revIdx(colIdx)])).toLocaleTimeString();
dataCols += '<span title="' + timeString + '">' + formattedValue + '</span>';
}
else {
dataCols += formattedValue;
}
dataCols += '</div>';
});
var withChildrenClass = (curNode.children && curNode.children.length) ? ' with-children' : '';
var result =
'<div class="data-row data-row-' + (curNode.level - $scope.rootLevel) + withChildrenClass + ' ' + dataRowSubdued + ' ' + $scope.nodeMarker(curNode) + '">' +
'<div class="fqn-holder">' + escapeHtml(curNode.fqn) + '</div>' +
'<div class="node-icon ' + $scope.nodeIconClass(curNode.fqn) + '"> </div>' +
'<div class="' + $scope.nodeIconMarked(curNode) + '"> </div>' +
'<div class="' + $scope.nodeIconClassWasKilled(curNode) + '"> </div>' +
dataCols +
renderDisplayNameForNode(curNode) +
'</div>';
//$log.log($scope.pickedTraces); // The Tooltips has to be sent from the server. See ABottomUpPageDefinition and ATracePageDefinition
//$log.log("xx="+curNode.tooltip);
//$log.log("xx="+curNode.wasKilled);
result += htmlForChildrenDiv(curNode);
return result;
}
function secondsToTime(secs) {
secs = Math.round(secs/1000);
var hours = Math.floor(secs / (60 * 60));
var divisor_for_minutes = secs % (60 * 60);
var minutes = Math.floor(divisor_for_minutes / 60);
var divisor_for_seconds = divisor_for_minutes % 60;
var seconds = Math.ceil(divisor_for_seconds);
var obj = {
"h": hours,
"m": minutes,
"s": seconds
};
return obj;
}
function renderDisplayNameForNode(curNode){
var rc = '';
if (!curNode || !curNode.name || !curNode.tooltip || $scope.showDataTooltips != 1) {
rc += '<div class="node-text" style="margin-right: ' + $scope.totalDataWidth + 'px;">' + renderSql(curNode) + '</div>';
} else {
rc += '<div data-toggle="data-tooltip" class="node-text" style="margin-right: ' + $scope.totalDataWidth + 'px;" ' + renderTooltip(curNode) + '>' + escapeHtml(curNode.name) + '</div>';
}
return rc;
}
function renderSql(curNode) {
if (!curNode || !curNode.name || !curNode.tooltip){
return escapeHtml(curNode.name);
}
var rc = curNode.name;
curNode.tooltip.forEach(function(entry) {
rc = rc.replace('?', entry.value);
}, this);
return rc;
}
function renderTooltip(curNode) {
if (!curNode || !curNode.tooltip || $scope.showDataTooltips != 1){
return '';
}
var rc = '';
curNode.tooltip.forEach(function(entry) {
rc += '(';
rc += entry.id;
rc += '=';
rc += entry.value;
rc += ')';
rc += ' ';
}, this);
return 'title="' + rc + '"';
}
function htmlForChildrenDiv(curNode, shouldRender) {
if(! curNode.children || curNode.children.length === 0) {
return '';
}
if(shouldRender || $scope.isExpanded(curNode)) {
var result = '';
result += '<div class="children" style="display: ' + $scope.expansionStyle(curNode) + ';">';
angular.forEach(curNode.children, function(child) {
result += htmlForTreeNode(child, $scope.rootLevel);
});
result += '</div>';
return result;
}
else {
return '<div class="children unrendered"></div>';
}
}
});
|
apache-2.0
|
live-ontologies/elk-reasoner
|
elk-reasoner/src/test/java/org/semanticweb/elk/reasoner/ReasoningCorrectnessTestWithInterrupts.java
|
2309
|
/*
* #%L
* ELK Reasoner
*
* $Id$
* $HeadURL$
* %%
* Copyright (C) 2011 - 2012 Department of Computer Science, University of Oxford
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.semanticweb.elk.reasoner;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.semanticweb.elk.testing.PolySuite;
import org.semanticweb.elk.testing.TestInput;
import org.semanticweb.elk.testing.TestManifestWithOutput;
/**
* Runs tests for all pairs of test input and expected output in the test
* directory. Computes the actual test output with interruptions.
*
* @author Pavel Klinov
*
* pavel.klinov@uni-ulm.de
* @author Peter Skocovsky
*
* @param <O>
* The type of test output.
*/
@RunWith(PolySuite.class)
public abstract class ReasoningCorrectnessTestWithInterrupts<I extends TestInput, O, TM extends TestManifestWithOutput<I, O>, TD extends ReasoningTestWithOutputAndInterruptsDelegate<O>>
extends ReasoningCorrectnessTestWithOutput<I, O, TM, TD> {
public ReasoningCorrectnessTestWithInterrupts(final TM testManifest,
final TD testDelegate) {
super(testManifest, testDelegate);
}
/**
* Checks that the actual test output is the same as the expected output
* after it is computed with interruptions.
*
* @throws Exception
*/
@Test
public void testWithInterruptions() throws Exception {
getDelegate().initWithInterrupts();
O actualOutput;
while (true) {
try {
actualOutput = getDelegate().getActualOutput();
} catch (final Exception e) {
if (getDelegate().getInterruptionExceptionClass()
.isInstance(e)) {
continue;
}
throw e;
}
break;
}
getManifest().compare(actualOutput);
}
}
|
apache-2.0
|
Lemon-han/MobilSafe
|
mobilesafe/src/main/java/com/emma/mobilesafe/acitivity/BaseSetUpAppCompatActivity.java
|
1501
|
package com.emma.mobilesafe.acitivity;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
/**
* Created by Administrator on 2017/4/1.
*/
public abstract class BaseSetUpAppCompatActivity extends AppCompatActivity {
private GestureDetector gestureDetector;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
gestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
if (e1.getX() - e2.getX() > 0) {
//下一页
showNextPage();
}
if (e1.getX() - e2.getX() < 0) {
showPrePage();
}
return super.onFling(e1, e2, velocityX, velocityY);
}
});
}
//1 监听屏幕上相应事件的类型
@Override
public boolean onTouchEvent(MotionEvent event) {
gestureDetector.onTouchEvent(event);
return super.onTouchEvent(event);
}
protected abstract void showPrePage();
protected abstract void showNextPage();
public void nextPage(View view) {
showNextPage();
}
public void prePage(View view) {
showPrePage();
}
}
|
apache-2.0
|
rogerthat-platform/gae-plugin-framework
|
src/framework/server/framework/bizz/job/__init__.py
|
4544
|
# -*- coding: utf-8 -*-
# Copyright 2017 GIG Technology NV
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# @@license_version:1.3@@
import inspect
from google.appengine.api import taskqueue
from google.appengine.datastore import datastore_rpc
from google.appengine.ext import deferred, db, ndb
from google.appengine.ext.deferred import deferred
from framework.consts import HIGH_LOAD_CONTROLLER_QUEUE, HIGH_LOAD_WORKER_QUEUE
from framework.utils import chunks
from mcfw.properties import azzert
MODE_SINGLE = 1
MODE_BATCH = 2
def run_job(qry_function, qry_function_args, worker_function, worker_function_args, mode=MODE_SINGLE,
batch_size=50, batch_timeout=0, qry_transactional=False, worker_queue=HIGH_LOAD_WORKER_QUEUE):
qry_function_args = qry_function_args or []
worker_function_args = worker_function_args or []
azzert(inspect.isfunction(qry_function), 'Only functions allowed for argument qry_function')
azzert(inspect.isfunction(worker_function), 'Only functions allowed for argument worker_function')
azzert(mode in (MODE_SINGLE, MODE_BATCH))
azzert(isinstance(qry_function_args, list), 'qry_function_args must be a list')
azzert(isinstance(worker_function_args, list), 'worker_function_args must be a list')
azzert(batch_size <= 500)
# batch_size shouldn't be too high in case your keys are large, else you might go over the max task size of 100KB
deferred.defer(_run_qry, qry_function, qry_function_args, worker_function, worker_function_args, mode, batch_size,
batch_timeout, qry_transactional, worker_queue=worker_queue, _transactional=db.is_in_transaction(),
_queue=HIGH_LOAD_CONTROLLER_QUEUE)
def _exec_qry(qry_function, qry_function_args, cursor, fetch_size):
qry = qry_function(*qry_function_args)
if isinstance(qry, ndb.Query):
items, new_cursor, has_more = qry.fetch_page(fetch_size, start_cursor=cursor, keys_only=True)
else:
qry.with_cursor(cursor)
items = qry.fetch(fetch_size)
new_cursor = qry.cursor()
has_more = len(items) == fetch_size # might not always be true but it's a good guess
return items, new_cursor, has_more
def _run_qry(qry_function, qry_function_args, worker_function, worker_function_args, mode, batch_size, batch_timeout,
batch_timeout_counter=0, qry_transactional=False, cursor=None, worker_queue=HIGH_LOAD_WORKER_QUEUE):
if mode == MODE_SINGLE:
fetch_size = taskqueue.MAX_TASKS_PER_ADD
else:
fetch_size = min(int(taskqueue.MAX_TASKS_PER_ADD * batch_size), datastore_rpc.BaseConnection.MAX_GET_KEYS)
if qry_transactional:
items, new_cursor, has_more = db.run_in_transaction(_exec_qry, qry_function, qry_function_args, cursor,
fetch_size)
else:
items, new_cursor, has_more = _exec_qry(qry_function, qry_function_args, cursor, fetch_size)
if not items:
return
tasks = []
taskargs = {
'url': deferred._DEFAULT_URL,
'headers': deferred._TASKQUEUE_HEADERS,
}
count_down = batch_timeout_counter
if mode == MODE_SINGLE:
for item in items:
pickled = deferred.serialize(worker_function, item, *worker_function_args)
tasks.append(taskqueue.Task(payload=pickled, countdown=count_down, **taskargs))
count_down += batch_timeout
else:
for keys in chunks(items, batch_size):
pickled = deferred.serialize(worker_function, keys, *worker_function_args)
tasks.append(taskqueue.Task(payload=pickled, countdown=count_down, **taskargs))
count_down += batch_timeout
taskqueue.Queue(worker_queue).add(tasks)
if has_more:
deferred.defer(_run_qry, qry_function, qry_function_args, worker_function, worker_function_args, mode,
batch_size, batch_timeout, count_down, qry_transactional, new_cursor, worker_queue,
_queue=HIGH_LOAD_CONTROLLER_QUEUE)
|
apache-2.0
|
vladmihalcea/high-performance-java-persistence
|
core/src/test/java/com/vladmihalcea/book/hpjp/util/providers/LockType.java
|
134
|
package com.vladmihalcea.book.hpjp.util.providers;
/**
* @author Vlad Mihalcea
*/
public enum LockType {
LOCKS,
MVLOCKS,
MVCC
}
|
apache-2.0
|
sergio11/struts2-hibernate
|
ejercicio4-web/src/main/java/converters/AuthorConverter.java
|
1587
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package converters;
import com.google.inject.Inject;
import com.opensymphony.xwork2.conversion.TypeConversionException;
import facade.AuthorFacadeLocal;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import models.Author;
import org.apache.struts2.util.StrutsTypeConverter;
/**
*
* @author sergio
*/
public class AuthorConverter extends StrutsTypeConverter {
@Inject
private AuthorFacadeLocal authorFacade;
@Override
public Object convertFromString(Map map, String[] values, Class type){
try{
Set<Author> authors = new HashSet();
for(String value: values){
Author author = authorFacade.find(Long.valueOf(value));
authors.add(author);
}
return authors;
} catch(Exception e){
e.printStackTrace();
Logger.getLogger(AuthorConverter.class.getName()).log(Level.INFO, "El campo autor no es válido");
throw new TypeConversionException("El campo autor no es válido");
}
}
@Override
public String convertToString(Map map, Object o) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
}
|
apache-2.0
|
bcgov/MyGovBC-MSP
|
src/app/modules/benefit/pages/personal-info/personal-info.component.ts
|
3090
|
import {ChangeDetectorRef, Component, QueryList, ViewChild, ViewChildren} from '@angular/core';
import {Router} from '@angular/router';
import {debounceTime, distinctUntilChanged} from 'rxjs/operators';
import {ProcessService} from '../../../../services/process.service';
import {NgForm} from '@angular/forms';
import {PersonalDetailsRetroSuppbenComponent} from '../../components/personal-details-retro-suppben/personal-details-retro-suppben.component';
import {BaseComponent} from '../../../../models/base.component';
import {BenefitApplication} from '../../models/benefit-application.model';
import {MspBenefitDataService} from '../../services/msp-benefit-data.service';
import { CANADA } from 'moh-common-lib';
@Component({
templateUrl: './personal-info.component.html',
styleUrls: ['./personal-info.component.scss']
})
export class BenefitPersonalInfoComponent extends BaseComponent {
static ProcessStepNum = 1;
lang = require('./i18n');
@ViewChild('formRef') personalInfoForm: NgForm;
//@ViewChildren(BenefitPersonalDetailComponent) personalDetailsComponent: QueryList<BenefitPersonalDetailComponent>;
@ViewChildren(PersonalDetailsRetroSuppbenComponent) personalDetailsComponent: QueryList<PersonalDetailsRetroSuppbenComponent>;
//@ViewChild('address') address: MspAddressComponent;
//@ViewChild('phone') phone: MspPhoneComponent;
benefitApplication: BenefitApplication;
constructor(private dataService: MspBenefitDataService,
private _router: Router,
private _processService: ProcessService,
cd: ChangeDetectorRef) {
super(cd);
this.benefitApplication = this.dataService.benefitApp;
this._processService.setStep(BenefitPersonalInfoComponent.ProcessStepNum, false);
// if the country is blank or null or undefined then assign Canada By Default //DEF-153
if (!this.benefitApplication.mailingAddress.country || this.benefitApplication.mailingAddress.country.trim().length === 0 ) {
this.benefitApplication.mailingAddress.country = CANADA;
}
}
ngAfterViewInit() {
this.personalInfoForm.valueChanges.pipe(
debounceTime(250),
distinctUntilChanged()
).subscribe( () => {
this.dataService.saveBenefitApplication();
});
}
ngOnInit() {
this.initProcessMembers(BenefitPersonalInfoComponent.ProcessStepNum, this._processService);
}
onChange() {
this.dataService.saveBenefitApplication();
}
onSubmit() {
this._processService.setStep(BenefitPersonalInfoComponent.ProcessStepNum, true);
this._router.navigate(['/benefit/spouse-info']);
}
isValid(): boolean {
return this.dataService.benefitApp.isUniquePhns && this.dataService.benefitApp.isUniqueSin;
}
get canContinue(): boolean {
return (
this.isAllValid() &&
this.benefitApplication.applicant.assistYearDocs &&
this.benefitApplication.applicant.assistYearDocs.length > 0
);
}
}
|
apache-2.0
|
bigtester/automation-test-engine
|
org.bigtester.ate.core/src/main/java/org/bigtester/ate/model/asserter/PageElementExistenceAsserter.java
|
4518
|
/*******************************************************************************
* ATE, Automation Test Engine
*
* Copyright 2014, Montreal PROT, or individual contributors as
* indicated by the @author tags or express copyright attribution
* statements applied by the authors. All third-party contributions are
* distributed under license by Montreal PROT.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package org.bigtester.ate.model.asserter;
import org.bigtester.ate.constant.EnumAssertPriority;
import org.bigtester.ate.constant.EnumAssertResult;
import org.bigtester.ate.model.data.IStepERValue;
import org.bigtester.ate.model.data.ItemCompareResult;
import org.bigtester.ate.model.data.StepErElementExistenceValue;
import org.bigtester.ate.model.data.dbtable.StepErElementExistence;
import org.bigtester.ate.model.page.atewebdriver.exception.BrowserUnexpectedException;
import org.bigtester.ate.model.page.elementfind.IElementFind;
import org.bigtester.ate.model.page.page.ATEPageFactory;
import org.bigtester.ate.model.page.page.IATEPageFactory;
import org.bigtester.ate.model.page.page.IPageObject;
import org.bigtester.ate.model.page.page.MyWebElement;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.TimeoutException;
// TODO: Auto-generated Javadoc
/**
* This class PageElementExistenceAsserter defines ....
*
* @author Peidong Hu
*
*/
public class PageElementExistenceAsserter extends
AbstractExpectedResultAsserter implements IExpectedResultAsserter,
IStepExecutionResult {
/** The step er value. */
private StepErElementExistenceValue stepERValue;
/**
* @param pageObj
*/
public PageElementExistenceAsserter(final IPageObject pageObj,
IStepERValue stepERValue) {
super();
setResultPage(pageObj);
this.stepERValue = (StepErElementExistenceValue) stepERValue.getERValue();
setExecResult(this);
}
/**
* {@inheritDoc}
*/
@Override
public void assertER() {
for (int index = 0; index < stepERValue.getValue().size(); index++) {
IATEPageFactory ipf = ATEPageFactory.getInstance();
StepErElementExistence sErEE = stepERValue.getValue().get(index);
MyWebElement<?> webelement = ipf.getMyWebElement(
sErEE.getElementFindBy(), sErEE.getElementFindByValue(),
getResultPage().getMyWd());
try {
((IElementFind) webelement.getTestObjectFinder()).doFind(
getResultPage().getMyWd(), ((IElementFind) webelement
.getTestObjectFinder()).getFindByValue());
ItemCompareResult icr = new ItemCompareResult(sErEE
.getElementFindBy().toString(),
sErEE.getElementFindByValue(),
EnumAssertResult.PAGEELEMENTEXIST.toString(),
sErEE.getAssertPriority(),
EnumAssertResult.PAGEELEMENTEXIST);
getExecResult().getComparedItemResults().put(
sErEE.getIdColumn(), icr);
super.appendAssertReportMSG(icr);
} catch (NoSuchElementException | TimeoutException |BrowserUnexpectedException et) {
ItemCompareResult icr = new ItemCompareResult(sErEE
.getElementFindBy().toString(),
sErEE.getElementFindByValue(),
EnumAssertResult.PAGEELEMENTNOTEXIST.toString(),
sErEE.getAssertPriority(),
EnumAssertResult.PAGEELEMENTNOTEXIST);
getExecResult().getComparedItemResults().put(
sErEE.getIdColumn(), icr);
getExecResult().getFailedItemResults().put(sErEE.getIdColumn(),
icr);
EnumAssertPriority failedPriority = getStepERValue().getValue()
.get(index).getAssertPriority();
if (failedPriority.equals(EnumAssertPriority.HIGH)) {
setFlagFailCase(true);
}
super.appendAssertReportMSG(icr);
}
}
}
/**
* @return the stepERValue
*/
public StepErElementExistenceValue getStepERValue() {
return stepERValue;
}
/**
* @param stepERValue
* the stepERValue to set
*/
public void setStepERValue(StepErElementExistenceValue stepERValue) {
this.stepERValue = stepERValue;
}
}
|
apache-2.0
|
oxlade39/STorrent
|
src/test/scala/io/github/oxlade39/storrent/peer/BitfieldTest.scala
|
981
|
package io.github.oxlade39.storrent.peer
import org.scalatest.WordSpecLike
import org.scalatest.MustMatchers
/**
* @author dan
*/
class BitfieldTest extends WordSpecLike with MustMatchers {
import io.github.oxlade39.storrent.test.util.Files.ubuntuTorrent
"Bitfield" must {
"pad up to multiple of 8" in {
Bitfield.padded(true) mustEqual Bitfield(Seq(true) ++ Seq.fill(7)(false))
Bitfield.padded(true, false) mustEqual Bitfield(Seq(true, false) ++ Seq.fill(6)(false))
Bitfield(Seq.fill(8)(true) ++ Seq(true, false, true)).padded mustEqual
Bitfield(Seq.fill(8)(true) ++ Seq(true, false, true) ++ Seq.fill(5)(false))
}
"trims to numbers of pieces in torrent" in {
val bitfieldWithCorrectNumberOfPieces = Bitfield(Seq.fill(ubuntuTorrent.pieceCount)(true))
val paddedThenTrimmed = bitfieldWithCorrectNumberOfPieces.padded.trimmed(ubuntuTorrent)
bitfieldWithCorrectNumberOfPieces mustEqual paddedThenTrimmed
}
}
}
|
apache-2.0
|
pierre-filliolaud/indexcity
|
indexcity-gateway/src/main/java/io/indexcity/gateway/web/rest/UserJWTController.java
|
2191
|
package io.indexcity.gateway.web.rest;
import io.indexcity.gateway.security.jwt.JWTConfigurer;
import io.indexcity.gateway.security.jwt.TokenProvider;
import io.indexcity.gateway.web.rest.vm.LoginVM;
import java.util.Collections;
import com.codahale.metrics.annotation.Timed;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import javax.inject.Inject;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
@RestController
@RequestMapping("/api")
public class UserJWTController {
@Inject
private TokenProvider tokenProvider;
@Inject
private AuthenticationManager authenticationManager;
@RequestMapping(value = "/authenticate", method = RequestMethod.POST)
@Timed
public ResponseEntity<?> authorize(@Valid @RequestBody LoginVM loginVM, HttpServletResponse response) {
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginVM.getUsername(), loginVM.getPassword());
try {
Authentication authentication = this.authenticationManager.authenticate(authenticationToken);
SecurityContextHolder.getContext().setAuthentication(authentication);
boolean rememberMe = (loginVM.isRememberMe() == null) ? false : loginVM.isRememberMe();
String jwt = tokenProvider.createToken(authentication, rememberMe);
response.addHeader(JWTConfigurer.AUTHORIZATION_HEADER, "Bearer " + jwt);
return ResponseEntity.ok(new JWTToken(jwt));
} catch (AuthenticationException exception) {
return new ResponseEntity<>(Collections.singletonMap("AuthenticationException",exception.getLocalizedMessage()), HttpStatus.UNAUTHORIZED);
}
}
}
|
apache-2.0
|
xnopre/code-elevator-team05
|
test/utils/CallTest.java
|
684
|
package utils;
import static org.fest.assertions.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static utils.Direction.DOWN;
import static utils.Direction.UP;
import org.junit.Test;
public class CallTest {
@Test
public void test_toString() {
assertEquals("ElevatorCall[floor=1, direction=DOWN]", new Call(1, Direction.DOWN).toString());
}
@Test
public void test_equals() {
final Call call = new Call(1, DOWN);
assertThat(call).isEqualTo(call);
assertThat(new Call(1, DOWN)).isEqualTo(new Call(1, DOWN));
assertThat(new Call(1, DOWN)).isNotEqualTo(new Call(2, DOWN));
assertThat(new Call(1, DOWN)).isNotEqualTo(new Call(1, UP));
}
}
|
apache-2.0
|
xasx/camunda-bpm-platform
|
engine/src/test/java/org/camunda/bpm/engine/test/api/authorization/VariableInstanceAuthorizationTest.java
|
15020
|
/*
* Copyright © 2013-2019 camunda services GmbH and various authors (info@camunda.com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.camunda.bpm.engine.test.api.authorization;
import static org.camunda.bpm.engine.authorization.Authorization.ANY;
import static org.camunda.bpm.engine.authorization.Permissions.READ;
import static org.camunda.bpm.engine.authorization.Permissions.READ_INSTANCE;
import static org.camunda.bpm.engine.authorization.TaskPermissions.READ_VARIABLE;
import static org.camunda.bpm.engine.authorization.ProcessDefinitionPermissions.READ_INSTANCE_VARIABLE;
import static org.camunda.bpm.engine.authorization.Resources.PROCESS_DEFINITION;
import static org.camunda.bpm.engine.authorization.Resources.PROCESS_INSTANCE;
import static org.camunda.bpm.engine.authorization.Resources.TASK;
import org.camunda.bpm.engine.impl.AbstractQuery;
import org.camunda.bpm.engine.runtime.VariableInstance;
import org.camunda.bpm.engine.runtime.VariableInstanceQuery;
/**
* @author Roman Smirnov
*
*/
public class VariableInstanceAuthorizationTest extends AuthorizationTest {
protected static final String PROCESS_KEY = "oneTaskProcess";
protected static final String CASE_KEY = "oneTaskCase";
protected String deploymentId;
protected boolean ensureSpecificVariablePermission;
@Override
public void setUp() throws Exception {
deploymentId = createDeployment(null,
"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml",
"org/camunda/bpm/engine/test/api/authorization/oneTaskCase.cmmn").getId();
ensureSpecificVariablePermission = processEngineConfiguration.isEnforceSpecificVariablePermission();
super.setUp();
}
@Override
public void tearDown() {
super.tearDown();
deleteDeployment(deploymentId);
processEngineConfiguration.setEnforceSpecificVariablePermission(ensureSpecificVariablePermission);
}
public void testProcessVariableQueryWithoutAuthorization() {
// given
startProcessInstanceByKey(PROCESS_KEY, getVariables());
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testCaseVariableQueryWithoutAuthorization () {
// given
createCaseInstanceByKey(CASE_KEY, getVariables());
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
public void testProcessLocalTaskVariableQueryWithoutAuthorization () {
// given
startProcessInstanceByKey(PROCESS_KEY);
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testCaseLocalTaskVariableQueryWithoutAuthorization () {
// given
createCaseInstanceByKey(CASE_KEY);
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
public void testStandaloneTaskVariableQueryWithoutAuthorization() {
// given
String taskId = "myTask";
createTask(taskId);
setTaskVariable(taskId, VARIABLE_NAME, VARIABLE_VALUE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
deleteTask(taskId, true);
}
public void testProcessVariableQueryWithReadPermissionOnProcessInstance() {
// given
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY, getVariables()).getId();
createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessVariableQueryWithReadInstancesPermissionOnOneTaskProcess() {
// given
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY, getVariables()).getId();
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessVariableQueryWithReadInstanceVariablePermission() {
// given
setReadVariableAsDefaultReadVariablePermission();
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY, getVariables()).getId();
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE_VARIABLE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
// CAM-9888
public void failingTestProcessVariableQueryWithReadVariablePermission() {
// given
setReadVariableAsDefaultReadVariablePermission();
startProcessInstanceByKey(PROCESS_KEY, getVariables());
createGrantAuthorization(TASK, ANY, userId, READ_VARIABLE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testProcessVariableQueryWithReadProcessInstanceWhenReadVariableIsEnabled() {
// given
setReadVariableAsDefaultReadVariablePermission();
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY, getVariables()).getId();
createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testProcessVariableQueryWithReadTaskWhenReadVariableIsEnabled() {
// given
setReadVariableAsDefaultReadVariablePermission();
startProcessInstanceByKey(PROCESS_KEY, getVariables()).getId();
createGrantAuthorization(TASK, ANY, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testProcessLocalTaskVariableQueryWithReadPermissionOnTask() {
// given
startProcessInstanceByKey(PROCESS_KEY);
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
public void testProcessLocalTaskVariableQueryWithMultiple() {
// given
startProcessInstanceByKey(PROCESS_KEY);
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ);
createGrantAuthorization(TASK, ANY, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
}
public void testProcessLocalTaskVariableQueryWithReadPermissionOnProcessInstance() {
// given
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessLocalTaskVariableQueryWithReadPermissionOnOneProcessTask() {
// given
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessLocalTaskVariableQueryWithReadInstanceVariablePermission() {
// given
setReadVariableAsDefaultReadVariablePermission();
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE_VARIABLE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessLocalTaskVariableQueryWithReadVariablePermission() {
// given
setReadVariableAsDefaultReadVariablePermission();
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ_VARIABLE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
VariableInstance variable = query.singleResult();
assertNotNull(variable);
assertEquals(processInstanceId, variable.getProcessInstanceId());
}
public void testProcessLocalTaskVariableQueryWithReadProcessInstanceWhenReadVariableIsEnabled() {
// given
setReadVariableAsDefaultReadVariablePermission();
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testProcessLocalTaskVariableQueryWithReadTaskWhenReadVariableIsEnabled() {
// given
setReadVariableAsDefaultReadVariablePermission();
startProcessInstanceByKey(PROCESS_KEY);
String taskId = selectSingleTask().getId();
setTaskVariableLocal(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 0);
}
public void testStandaloneTaskVariableQueryWithReadPermissionOnTask() {
// given
String taskId = "myTask";
createTask(taskId);
setTaskVariable(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
deleteTask(taskId, true);
}
public void testStandaloneTaskVariableQueryWithReadVariablePermissionOnTask() {
// given
setReadVariableAsDefaultReadVariablePermission();
String taskId = "myTask";
createTask(taskId);
setTaskVariable(taskId, VARIABLE_NAME, VARIABLE_VALUE);
createGrantAuthorization(TASK, taskId, userId, READ_VARIABLE);
// when
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then
verifyQueryResults(query, 1);
deleteTask(taskId, true);
}
public void testMixedVariables() {
// given
String taskId = "myTask";
createTask(taskId);
setTaskVariable(taskId, VARIABLE_NAME, VARIABLE_VALUE);
String processInstanceId = startProcessInstanceByKey(PROCESS_KEY, getVariables()).getProcessInstanceId();
createCaseInstanceByKey(CASE_KEY, getVariables());
// when (1)
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then (1)
verifyQueryResults(query, 1);
// when (2)
createGrantAuthorization(TASK, taskId, userId, READ);
// then (2)
verifyQueryResults(query, 2);
// when (3)
createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);
// then (3)
verifyQueryResults(query, 3);
deleteTask(taskId, true);
}
public void testMixedVariablesWhenReadVariableIsEnabled() {
// given
setReadVariableAsDefaultReadVariablePermission();
String taskId = "myTask";
createTask(taskId);
setTaskVariable(taskId, VARIABLE_NAME, VARIABLE_VALUE);
startProcessInstanceByKey(PROCESS_KEY, getVariables()).getProcessInstanceId();
createCaseInstanceByKey(CASE_KEY, getVariables());
// when (1)
VariableInstanceQuery query = runtimeService.createVariableInstanceQuery();
// then (1)
verifyQueryResults(query, 1);
// when (2)
createGrantAuthorization(TASK, taskId, userId, READ_VARIABLE);
// then (2)
verifyQueryResults(query, 2);
// when (3)
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE_VARIABLE);
// then (3)
verifyQueryResults(query, 3);
deleteTask(taskId, true);
}
// helper ////////////////////////////////////////////////////////////////
protected void verifyQueryResults(VariableInstanceQuery query, int countExpected) {
verifyQueryResults((AbstractQuery<?, ?>) query, countExpected);
}
protected void setReadVariableAsDefaultReadVariablePermission() {
processEngineConfiguration.setEnforceSpecificVariablePermission(true);
}
}
|
apache-2.0
|
liuxing521a/itas-core
|
core/src/main/java/org/itas/core/GameObject.java
|
689
|
package org.itas.core;
/**
* <p>自动同步数据库基类</p>
* 所有自动 从数据库加载、自动修改数据库、自动删除等同步对象都需要继承此类；</br>
* 继承此类后需要不会自动生成Id，需要制定Id
* @author liuzhen<liuxing521a@gmail.com>
* @createTime 2014年12月15日下午4:25:47
*/
public abstract class GameObject extends GameBase {
protected GameObject(String Id) {
super(Id);
}
/**
* <p>自动生成对象</p>
* 注:需要指定id
* @param Id 新对象的id
* @return 生成的对象
*/
protected abstract <T extends GameObject> T autoInstance(String Id);
public int getCachedSize() {
return 86;
}
}
|
apache-2.0
|
Tecsisa/elastic4s
|
elastic4s-aws/src/main/scala/com/sksamuel/elastic4s/aws/Aws4ElasticClient.scala
|
3436
|
package com.sksamuel.elastic4s.aws
import com.sksamuel.elastic4s.ElasticsearchClientUri
import com.sksamuel.elastic4s.http.ElasticClient
import com.amazonaws.auth.{AWSStaticCredentialsProvider, BasicAWSCredentials, DefaultAWSCredentialsProviderChain}
import com.amazonaws.regions.DefaultAwsRegionProviderChain
import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder
import org.apache.http.protocol.HttpContext
import org.apache.http.{HttpRequest, HttpRequestInterceptor}
case class Aws4ElasticConfig(endpoint: String, key: String, secret: String, region: String, service: String = "es") {
require(key.length > 16 && key.length < 128 && key.matches("[\\w]+"), "Key id must be between 16 and 128 characters.")
}
object Aws4ElasticClient {
/**
* Creates ES HttpClient with aws4 request signer interceptor using custom config (key, secret, region and service).
*/
def apply(config: Aws4ElasticConfig): ElasticClient = {
val elasticUri = ElasticsearchClientUri(config.endpoint)
ElasticClient(elasticUri, httpClientConfigCallback = new SignedClientConfig(config))
}
/**
* Convenience method to create ES HttpClient with aws4 request signer interceptor using default aws environment variables.
* See <a href="http://docs.aws.amazon.com/cli/latest/userguide/cli-environment.html">amazon environment variables documentation</a>
*/
def apply(endpoint: String): ElasticClient = {
val elasticUri = ElasticsearchClientUri(endpoint)
ElasticClient(elasticUri, httpClientConfigCallback = new DefaultSignedClientConfig)
}
}
private class SignedClientConfig(config: Aws4ElasticConfig) extends HttpClientConfigCallback {
override def customizeHttpClient(httpClientBuilder: HttpAsyncClientBuilder): HttpAsyncClientBuilder =
httpClientBuilder.addInterceptorLast(new Aws4HttpRequestInterceptor(config))
}
private class DefaultSignedClientConfig extends HttpClientConfigCallback {
override def customizeHttpClient(httpClientBuilder: HttpAsyncClientBuilder): HttpAsyncClientBuilder =
httpClientBuilder.addInterceptorLast(new DefaultAws4HttpRequestInterceptor)
}
private class Aws4HttpRequestInterceptor(config: Aws4ElasticConfig) extends HttpRequestInterceptor {
private val chainProvider = new AWSStaticCredentialsProvider(new BasicAWSCredentials(config.key, config.secret))
private val signer = new Aws4RequestSigner(chainProvider, config.region, config.service)
override def process(request: HttpRequest, context: HttpContext): Unit = signer.withAws4Headers(request)
}
/**
* Default Request Interceptor for convenience. Uses the default environment variable names.
* See <a href="http://docs.aws.amazon.com/cli/latest/userguide/cli-environment.html">amazon environment variable documentation</a>
* See <a href="https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-region-selection.html"> default region selection</a>
*/
private class DefaultAws4HttpRequestInterceptor extends HttpRequestInterceptor {
private val defaultChainProvider = new DefaultAWSCredentialsProviderChain
private val regionProvider = new DefaultAwsRegionProviderChain
private val signer = new Aws4RequestSigner(defaultChainProvider, regionProvider.getRegion)
override def process(request: HttpRequest, context: HttpContext): Unit = signer.withAws4Headers(request)
}
|
apache-2.0
|
ok2c/httpclient
|
httpclient5/src/main/java/org/apache/hc/client5/http/impl/async/Http2AsyncClientEventHandlerFactory.java
|
9547
|
/*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
*/
package org.apache.hc.client5.http.impl.async;
import java.io.IOException;
import java.util.List;
import org.apache.hc.client5.http.impl.ConnPoolSupport;
import org.apache.hc.core5.http.Header;
import org.apache.hc.core5.http.HttpConnection;
import org.apache.hc.core5.http.config.CharCodingConfig;
import org.apache.hc.core5.http.nio.AsyncPushConsumer;
import org.apache.hc.core5.http.nio.HandlerFactory;
import org.apache.hc.core5.http.protocol.HttpProcessor;
import org.apache.hc.core5.http2.config.H2Config;
import org.apache.hc.core5.http2.frame.FramePrinter;
import org.apache.hc.core5.http2.frame.RawFrame;
import org.apache.hc.core5.http2.impl.nio.ClientHttp2StreamMultiplexerFactory;
import org.apache.hc.core5.http2.impl.nio.Http2OnlyClientProtocolNegotiator;
import org.apache.hc.core5.http2.impl.nio.Http2StreamListener;
import org.apache.hc.core5.reactor.IOEventHandler;
import org.apache.hc.core5.reactor.IOEventHandlerFactory;
import org.apache.hc.core5.reactor.ProtocolIOSession;
import org.apache.hc.core5.util.Args;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
class Http2AsyncClientEventHandlerFactory implements IOEventHandlerFactory {
private final Logger wireLog = LoggerFactory.getLogger("org.apache.hc.client5.http.wire");
private final Logger headerLog = LoggerFactory.getLogger("org.apache.hc.client5.http.headers");
private final Logger frameLog = LoggerFactory.getLogger("org.apache.hc.client5.http2.frame");
private final Logger framePayloadLog = LoggerFactory.getLogger("org.apache.hc.client5.http2.frame.payload");
private final Logger flowCtrlLog = LoggerFactory.getLogger("org.apache.hc.client5.http2.flow");
private final HttpProcessor httpProcessor;
private final HandlerFactory<AsyncPushConsumer> exchangeHandlerFactory;
private final H2Config h2Config;
private final CharCodingConfig charCodingConfig;
Http2AsyncClientEventHandlerFactory(
final HttpProcessor httpProcessor,
final HandlerFactory<AsyncPushConsumer> exchangeHandlerFactory,
final H2Config h2Config,
final CharCodingConfig charCodingConfig) {
this.httpProcessor = Args.notNull(httpProcessor, "HTTP processor");
this.exchangeHandlerFactory = exchangeHandlerFactory;
this.h2Config = h2Config != null ? h2Config : H2Config.DEFAULT;
this.charCodingConfig = charCodingConfig != null ? charCodingConfig : CharCodingConfig.DEFAULT;
}
@Override
public IOEventHandler createHandler(final ProtocolIOSession ioSession, final Object attachment) {
final Logger sessionLog = LoggerFactory.getLogger(ioSession.getClass());
if (sessionLog.isDebugEnabled()
|| wireLog.isDebugEnabled()
|| headerLog.isDebugEnabled()
|| frameLog.isDebugEnabled()
|| framePayloadLog.isDebugEnabled()
|| flowCtrlLog.isDebugEnabled()) {
final String id = ConnPoolSupport.getId(ioSession);
final ClientHttp2StreamMultiplexerFactory http2StreamHandlerFactory = new ClientHttp2StreamMultiplexerFactory(
httpProcessor,
exchangeHandlerFactory,
h2Config,
charCodingConfig,
new Http2StreamListener() {
final FramePrinter framePrinter = new FramePrinter();
private void logFrameInfo(final String prefix, final RawFrame frame) {
try {
final LogAppendable logAppendable = new LogAppendable(frameLog, prefix);
framePrinter.printFrameInfo(frame, logAppendable);
logAppendable.flush();
} catch (final IOException ignore) {
}
}
private void logFramePayload(final String prefix, final RawFrame frame) {
try {
final LogAppendable logAppendable = new LogAppendable(framePayloadLog, prefix);
framePrinter.printPayload(frame, logAppendable);
logAppendable.flush();
} catch (final IOException ignore) {
}
}
private void logFlowControl(final String prefix, final int streamId, final int delta, final int actualSize) {
final StringBuilder buffer = new StringBuilder();
buffer.append(prefix).append(" stream ").append(streamId).append(" flow control " )
.append(delta).append(" -> ")
.append(actualSize);
flowCtrlLog.debug(buffer.toString());
}
@Override
public void onHeaderInput(final HttpConnection connection, final int streamId, final List<? extends Header> headers) {
if (headerLog.isDebugEnabled()) {
for (int i = 0; i < headers.size(); i++) {
headerLog.debug(id + " << " + headers.get(i));
}
}
}
@Override
public void onHeaderOutput(final HttpConnection connection, final int streamId, final List<? extends Header> headers) {
if (headerLog.isDebugEnabled()) {
for (int i = 0; i < headers.size(); i++) {
headerLog.debug(id + " >> " + headers.get(i));
}
}
}
@Override
public void onFrameInput(final HttpConnection connection, final int streamId, final RawFrame frame) {
if (frameLog.isDebugEnabled()) {
logFrameInfo(id + " <<", frame);
}
if (framePayloadLog.isDebugEnabled()) {
logFramePayload(id + " <<", frame);
}
}
@Override
public void onFrameOutput(final HttpConnection connection, final int streamId, final RawFrame frame) {
if (frameLog.isDebugEnabled()) {
logFrameInfo(id + " >>", frame);
}
if (framePayloadLog.isDebugEnabled()) {
logFramePayload(id + " >>", frame);
}
}
@Override
public void onInputFlowControl(final HttpConnection connection, final int streamId, final int delta, final int actualSize) {
if (flowCtrlLog.isDebugEnabled()) {
logFlowControl(id + " <<", streamId, delta, actualSize);
}
}
@Override
public void onOutputFlowControl(final HttpConnection connection, final int streamId, final int delta, final int actualSize) {
if (flowCtrlLog.isDebugEnabled()) {
logFlowControl(id + " >>", streamId, delta, actualSize);
}
}
});
final LoggingIOSession loggingIOSession = new LoggingIOSession(ioSession, id, sessionLog, wireLog);
return new Http2OnlyClientProtocolNegotiator(loggingIOSession, http2StreamHandlerFactory, false);
}
final ClientHttp2StreamMultiplexerFactory http2StreamHandlerFactory = new ClientHttp2StreamMultiplexerFactory(
httpProcessor,
exchangeHandlerFactory,
h2Config,
charCodingConfig,
null);
return new Http2OnlyClientProtocolNegotiator(ioSession, http2StreamHandlerFactory, false);
}
}
|
apache-2.0
|
terma/gigaspace-routine
|
src/main/java/com/github/terma/gigaspaceroutine/comparators/StringKeyComparator.java
|
507
|
package com.github.terma.gigaspaceroutine.comparators;
import java.util.Comparator;
import java.util.Map;
public class StringKeyComparator implements Comparator<Map<String, Object>> {
private final String key;
public StringKeyComparator(String key) {
this.key = key;
}
@Override
public int compare(Map<String, Object> o1, Map<String, Object> o2) {
String v1 = (String) o1.get(key);
String v2 = (String) o2.get(key);
return v1.compareTo(v2);
}
}
|
apache-2.0
|
huruk/ebay2magento
|
Ebay2magento/Ebay2Magento.Classic/Properties/Settings.Designer.cs
|
999
|
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Ebay2Magento.Classic.Properties
{
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
{
private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
public static Settings Default
{
get
{
return defaultInstance;
}
}
}
}
|
apache-2.0
|
dpetkevich/telebot
|
main.py
|
5861
|
import StringIO
import json
import logging
import random
import urllib
import urllib2
import webapp2
# for sending images
from PIL import Image
import multipart
from webapp2_extras import sessions
# standard app engine imports
from google.appengine.api import urlfetch
from google.appengine.ext import ndb
import webapp2
TOKEN = '131959704:AAFUinpmkNRYhXuPSXleSbCrAvS4YnEL4J8'
BASE_URL = 'https://api.telegram.org/bot' + TOKEN + '/'
host = 'aiaas.pandorabots.com'
user_key = '8704f84cef67d2c4c1c487ce9aab7da2'
app_id = '1409612152298'
botname = 'benjamin'
# ================================
class EnableStatus(ndb.Model):
# key name: str(chat_id)
enabled = ndb.BooleanProperty(indexed=False, default=False)
# ================================
def setEnabled(chat_id, yes):
es = EnableStatus.get_or_insert(str(chat_id))
es.enabled = yes
es.put()
def getEnabled(chat_id):
es = EnableStatus.get_by_id(str(chat_id))
if es:
return es.enabled
return False
# ================================
class MeHandler(webapp2.RequestHandler):
def get(self):
urlfetch.set_default_fetch_deadline(60)
self.response.write(json.dumps(json.load(urllib2.urlopen(BASE_URL + 'getMe'))))
class GetUpdatesHandler(webapp2.RequestHandler):
def get(self):
urlfetch.set_default_fetch_deadline(60)
self.response.write(json.dumps(json.load(urllib2.urlopen(BASE_URL + 'getUpdates'))))
class SetWebhookHandler(webapp2.RequestHandler):
def get(self):
urlfetch.set_default_fetch_deadline(60)
url = self.request.get('url')
if url:
self.response.write(json.dumps(json.load(urllib2.urlopen(BASE_URL + 'setWebhook', urllib.urlencode({'url': url})))))
class WebhookHandler(webapp2.RequestHandler):
def post(self):
urlfetch.set_default_fetch_deadline(60)
body = json.loads(self.request.body)
logging.info('request body:')
logging.info(body)
self.response.write(json.dumps(body))
update_id = body['update_id']
message = body['message']
message_id = message.get('message_id')
date = message.get('date')
text = message.get('text')
fr = message.get('from')
chat = message['chat']
chat_id = chat['id']
if not text:
logging.info('no text')
return
def reply(msg=None, img=None):
if msg:
resp = urllib2.urlopen(BASE_URL + 'sendMessage', urllib.urlencode({
'chat_id': str(chat_id),
'text': msg.encode('utf-8'),
'disable_web_page_preview': 'true',
'reply_to_message_id': str(message_id),
})).read()
elif img:
resp = multipart.post_multipart(BASE_URL + 'sendPhoto', [
('chat_id', str(chat_id)),
('reply_to_message_id', str(message_id)),
], [
('photo', 'image.jpg', img),
])
else:
logging.error('no msg or img specified')
resp = None
logging.info('send response:')
logging.info(resp)
if text.startswith('/'):
if text == '/start':
reply('Bot enabled')
setEnabled(chat_id, True)
elif text == '/stop':
reply('Bot disabled')
setEnabled(chat_id, False)
elif text == '/image':
img = Image.new('RGB', (512, 512))
base = random.randint(0, 16777216)
pixels = [base+i*j for i in range(512) for j in range(512)] # generate sample image
img.putdata(pixels)
output = StringIO.StringIO()
img.save(output, 'JPEG')
reply(img=output.getvalue())
else:
reply('What command?')
# CUSTOMIZE FROM HERE
elif session.get('session_id') != None or session.get('client_name') != None:
session_id = session.get('session_id')
client_name = session.get('client_name')
query = "https://aiaas.pandorabots.com/atalk/" + str(app_id) + "/" + str(botname)
payload1 = {
'user_key' : str(user_key).encode('utf-8'),
"input": str(request_message).encode('utf-8'),
"client_name": str(client_name).encode('utf-8'),
'sessionid': str(session_id).encode('utf-8')
}
reply("dan's shit works")
else:
query = "https://aiaas.pandorabots.com/atalk/" + str(app_id) + "/" + str(botname)
payload1 = {
'user_key' : str(user_key).encode('utf-8'),
"input": str(request_message).encode('utf-8')
}
reply("dan's shit works")
# if getEnabled(chat_id):
# try:
# resp1 = json.load(urllib2.urlopen('http://www.simsimi.com/requestChat?lc=en&ft=1.0&req=' + urllib.quote_plus(text.encode('utf-8'))))
# back = resp1.get('res')
# except urllib2.HTTPError, err:
# logging.error(err)
# back = str(err)
# if not back:
# reply('okay...')
# elif 'I HAVE NO RESPONSE' in back:
# reply('you said something with no meaning')
# else:
# reply(back)
# else:
# logging.info('not enabled for chat_id {}'.format(chat_id))
app = webapp2.WSGIApplication([
('/me', MeHandler),
('/updates', GetUpdatesHandler),
('/set_webhook', SetWebhookHandler),
('/webhook', WebhookHandler),
], debug=True)
|
apache-2.0
|
cymcsg/UltimateRecyclerView
|
UltimateRecyclerView/ultimaterecyclerview/src/main/java/com/marshalchen/ultimaterecyclerview/stickyheadersrecyclerview/HeaderPositionCalculator.java
|
9713
|
package com.marshalchen.ultimaterecyclerview.stickyheadersrecyclerview;
import android.graphics.Rect;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.view.View;
import com.marshalchen.ultimaterecyclerview.stickyheadersrecyclerview.caching.HeaderProvider;
import com.marshalchen.ultimaterecyclerview.stickyheadersrecyclerview.calculation.DimensionCalculator;
import com.marshalchen.ultimaterecyclerview.stickyheadersrecyclerview.util.OrientationProvider;
/**
* Calculates the position and location of header views
*/
public class HeaderPositionCalculator {
private final StickyRecyclerHeadersAdapter mAdapter;
private final OrientationProvider mOrientationProvider;
private final HeaderProvider mHeaderProvider;
private final DimensionCalculator mDimensionCalculator;
public HeaderPositionCalculator(StickyRecyclerHeadersAdapter adapter, HeaderProvider headerProvider,
OrientationProvider orientationProvider, DimensionCalculator dimensionCalculator) {
mAdapter = adapter;
mHeaderProvider = headerProvider;
mOrientationProvider = orientationProvider;
mDimensionCalculator = dimensionCalculator;
}
/**
* Determines if an item in the list should have a header that is different than the item in the
* list that immediately precedes it. Items with no headers will always return false.
*
* @param position of the list item in questions
* @return true if this item has a different header than the previous item in the list
*/
public boolean hasNewHeader(int position) {
if (indexOutOfBounds(position)) {
return false;
}
long headerId = mAdapter.getHeaderId(position);
if (headerId < 0) {
return false;
}
return position == 0 || headerId != mAdapter.getHeaderId(position - 1);
}
private boolean indexOutOfBounds(int position) {
return position < 0 || position >= mAdapter.getItemCount();
}
public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstView, boolean firstHeader) {
int orientation = mOrientationProvider.getOrientation(recyclerView);
Rect bounds = getDefaultHeaderOffset(recyclerView, header, firstView, orientation);
if (firstHeader && isStickyHeaderBeingPushedOffscreen(recyclerView, header)) {
View viewAfterNextHeader = getFirstViewUnobscuredByHeader(recyclerView, header);
int firstViewUnderHeaderPosition = recyclerView.getChildAdapterPosition(viewAfterNextHeader);
View secondHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
translateHeaderWithNextHeader(recyclerView, mOrientationProvider.getOrientation(recyclerView), bounds,
header, viewAfterNextHeader, secondHeader);
}
return bounds;
}
private Rect getDefaultHeaderOffset(RecyclerView recyclerView, View header, View firstView, int orientation) {
int translationX, translationY;
Rect headerMargins = mDimensionCalculator.getMargins(header);
if (orientation == LinearLayoutManager.VERTICAL) {
translationX = firstView.getLeft() + headerMargins.left;
translationY = Math.max(
firstView.getTop() - header.getHeight() - headerMargins.bottom,
getListTop(recyclerView) + headerMargins.top);
} else {
translationY = firstView.getTop() + headerMargins.top;
translationX = Math.max(
firstView.getLeft() - header.getWidth() - headerMargins.right,
getListLeft(recyclerView) + headerMargins.left);
}
return new Rect(translationX, translationY, translationX + header.getWidth(),
translationY + header.getHeight());
}
private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, View stickyHeader) {
View viewAfterHeader = getFirstViewUnobscuredByHeader(recyclerView, stickyHeader);
int firstViewUnderHeaderPosition = recyclerView.getChildAdapterPosition(viewAfterHeader);
if (firstViewUnderHeaderPosition == RecyclerView.NO_POSITION) {
return false;
}
if (firstViewUnderHeaderPosition > 0 && hasNewHeader(firstViewUnderHeaderPosition)) {
View nextHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
Rect headerMargins = mDimensionCalculator.getMargins(stickyHeader);
if (mOrientationProvider.getOrientation(recyclerView) == LinearLayoutManager.VERTICAL) {
int topOfNextHeader = viewAfterHeader.getTop() - nextHeaderMargins.bottom - nextHeader.getHeight() - nextHeaderMargins.top;
int bottomOfThisHeader = recyclerView.getPaddingTop() + stickyHeader.getBottom() + headerMargins.top + headerMargins.bottom;
if (topOfNextHeader < bottomOfThisHeader) {
return true;
}
} else {
int leftOfNextHeader = viewAfterHeader.getLeft() - nextHeaderMargins.right - nextHeader.getWidth() - nextHeaderMargins.left;
int rightOfThisHeader = recyclerView.getPaddingLeft() + stickyHeader.getRight() + headerMargins.left + headerMargins.right;
if (leftOfNextHeader < rightOfThisHeader) {
return true;
}
}
}
return false;
}
private void translateHeaderWithNextHeader(RecyclerView recyclerView, int orientation, Rect translation,
View currentHeader, View viewAfterNextHeader, View nextHeader) {
Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
Rect stickyHeaderMargins = mDimensionCalculator.getMargins(currentHeader);
if (orientation == LinearLayoutManager.VERTICAL) {
int topOfStickyHeader = getListTop(recyclerView) + stickyHeaderMargins.top + stickyHeaderMargins.bottom;
int shiftFromNextHeader = viewAfterNextHeader.getTop() - nextHeader.getHeight() - nextHeaderMargins.bottom - nextHeaderMargins.top - currentHeader.getHeight() - topOfStickyHeader;
if (shiftFromNextHeader < topOfStickyHeader) {
translation.top += shiftFromNextHeader;
}
} else {
int leftOfStickyHeader = getListLeft(recyclerView) + stickyHeaderMargins.left + stickyHeaderMargins.right;
int shiftFromNextHeader = viewAfterNextHeader.getLeft() - nextHeader.getWidth() - nextHeaderMargins.right - nextHeaderMargins.left - currentHeader.getWidth() - leftOfStickyHeader;
if (shiftFromNextHeader < leftOfStickyHeader) {
translation.left += shiftFromNextHeader;
}
}
}
/**
* Returns the first item currently in the RecyclerView that is not obscured by a header.
*
* @param parent Recyclerview containing all the list items
* @return first item that is fully beneath a header
*/
private View getFirstViewUnobscuredByHeader(RecyclerView parent, View firstHeader) {
for (int i = 0; i < parent.getChildCount(); i++) {
View child = parent.getChildAt(i);
if (!itemIsObscuredByHeader(parent, child, firstHeader, mOrientationProvider.getOrientation(parent))) {
return child;
}
}
return null;
}
/**
* Determines if an item is obscured by a header
*
* @param parent
* @param item to determine if obscured by header
* @param header that might be obscuring the item
* @param orientation of the {@link RecyclerView}
* @return true if the item view is obscured by the header view
*/
private boolean itemIsObscuredByHeader(RecyclerView parent, View item, View header, int orientation) {
RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) item.getLayoutParams();
Rect headerMargins = mDimensionCalculator.getMargins(header);
int adapterPosition = parent.getChildAdapterPosition(item);
if (adapterPosition == RecyclerView.NO_POSITION || mHeaderProvider.getHeader(parent, adapterPosition) != header) {
// Resolves https://github.com/timehop/sticky-headers-recyclerview/issues/36
// Handles an edge case where a trailing header is smaller than the current sticky header.
return false;
}
if (orientation == LinearLayoutManager.VERTICAL) {
int itemTop = item.getTop() - layoutParams.topMargin;
int headerBottom = header.getBottom() + headerMargins.bottom + headerMargins.top;
if (itemTop > headerBottom) {
return false;
}
} else {
int itemLeft = item.getLeft() - layoutParams.leftMargin;
int headerRight = header.getRight() + headerMargins.right + headerMargins.left;
if (itemLeft > headerRight) {
return false;
}
}
return true;
}
private int getListTop(RecyclerView view) {
if (view.getLayoutManager().getClipToPadding()) {
return view.getPaddingTop();
} else {
return 0;
}
}
private int getListLeft(RecyclerView view) {
if (view.getLayoutManager().getClipToPadding()) {
return view.getPaddingLeft();
} else {
return 0;
}
}
}
|
apache-2.0
|
wdsgyj/DS
|
src/com/clark/ds/list/IListIterator.java
|
232
|
package com.clark.ds.list;
/**
* Created by clark on 2014/10/16.
*/
public interface IListIterator<T> {
boolean hasNext();
boolean hasPrev();
T next();
T prev();
boolean isHead();
boolean isTail();
}
|
apache-2.0
|
matobet/methanol-manager
|
backend/dal/src/test/java/cz/muni/fi/pa165/methanolmanager/dal/repository/BottleTest.java
|
5860
|
package cz.muni.fi.pa165.methanolmanager.dal.repository;
import cz.muni.fi.pa165.methanolmanager.dal.DalConfig;
import cz.muni.fi.pa165.methanolmanager.dal.domain.Bottle;
import cz.muni.fi.pa165.methanolmanager.dal.domain.Make;
import cz.muni.fi.pa165.methanolmanager.dal.domain.Producer;
import cz.muni.fi.pa165.methanolmanager.dal.domain.Store;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.inject.Inject;
import javax.transaction.Transactional;
import java.util.Arrays;
import java.util.Date;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
/*
* @author Martin Betak
*/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = DalConfig.class)
@Transactional
public class BottleTest {
@Inject
BottleRepository bottleRepository;
@Inject
MakeRepository makeRepository;
@Inject
ProducerRepository producerRepository;
@Inject
StoreRepository storeRepository;
private Producer bozkovProducer;
private Producer spisProducer;
private Make bozkov;
private Make spis;
private Store brnenka;
private Store tesco;
@Before
public void setup() {
setupProducers();
setupMakes();
setupStores();
}
private void setupProducers() {
bozkovProducer = new Producer();
bozkovProducer.setName("Bozkov s.r.o");
spisProducer = new Producer();
spisProducer.setName("Spis s.r.o");
producerRepository.save(bozkovProducer);
producerRepository.save(spisProducer);
}
private void setupMakes() {
bozkov = new Make();
bozkov.setName("Bozkov");
bozkov.setProducer(bozkovProducer);
spis = new Make();
spis.setName("Spis");
spis.setProducer(spisProducer);
makeRepository.save(bozkov);
makeRepository.save(spis);
}
private void setupStores() {
brnenka = new Store();
brnenka.setName("Brnenka");
tesco = new Store();
tesco.setName("Tesco");
storeRepository.save(brnenka);
storeRepository.save(tesco);
}
@Test
public void testCreateBottle() {
Bottle bottle = new Bottle();
bottle.setName("foo");
bottleRepository.save(bottle);
assertThat(bottleRepository.findAll(), is(Arrays.asList(bottle)));
}
@Test
public void testDeleteBottle() {
Bottle bottle = new Bottle();
bottle.setStampDate(new Date(System.currentTimeMillis() - 360000));
bottle.setName("Vodka");
Bottle bottle2 = new Bottle();
bottle2.setStampDate(new Date(System.currentTimeMillis() - 360000));
bottle2.setName("Bozkov");
Bottle bottle3 = new Bottle();
bottle3.setName("Becher");
bottleRepository.save(bottle);
bottleRepository.save(bottle2);
bottleRepository.save(bottle3);
Bottle deleteThisBottle = bottleRepository.findByName("Bozkov");
bottleRepository.delete(deleteThisBottle);
assertThat(bottleRepository.findByName("Bozkov"), nullValue());
}
@Test
public void testFindToxic() {
Bottle bottle = new Bottle();
bottle.setName("Vodka");
Bottle bottle2 = new Bottle();
bottle2.setName("Bozkov");
bottle2.setToxic(true);
bottleRepository.save(bottle);
bottleRepository.save(bottle2);
assertThat(bottleRepository.findAllToxic(), is(Arrays.asList(bottle2)));
}
@Test
public void testFindStamped() {
Bottle bottle = new Bottle();
bottle.setStampDate(new Date(System.currentTimeMillis() - 360000));
bottle.setName("Vodka");
Bottle bottle2 = new Bottle();
bottle2.setStampDate(new Date(System.currentTimeMillis() - 360000));
bottle2.setName("Bozkov");
Bottle bottle3 = new Bottle();
bottle3.setName("Becher");
bottleRepository.save(bottle);
bottleRepository.save(bottle2);
bottleRepository.save(bottle3);
assertThat(bottleRepository.findAllStamped().size(), equalTo(2));
}
@Test
public void testCountToxic() {
Bottle bottle = new Bottle();
bottle.setName("Vodka");
bottle.setMake(bozkov);
bottle.setStore(brnenka);
Bottle bottle2 = new Bottle();
bottle2.setName("Tuzemak");
bottle2.setToxic(true);
bottle2.setMake(bozkov);
bottle2.setStore(brnenka);
Bottle bottle3 = new Bottle();
bottle3.setName("Slivka");
bottle3.setToxic(true);
bottle3.setMake(spis);
bottle3.setStore(tesco);
Bottle bottle4 = new Bottle();
bottle4.setName("Ceresna");
bottle4.setMake(spis);
bottle4.setStore(tesco);
bottleRepository.save(bottle);
bottleRepository.save(bottle2);
bottleRepository.save(bottle3);
bottleRepository.save(bottle4);
assertThat(bottleRepository.countToxicByMake(bozkov), is(equalTo(1l)));
assertThat(bottleRepository.countToxicByMake(spis), is(equalTo(1l)));
assertThat(bottleRepository.countToxicByProducer(bozkovProducer), is(equalTo(1l)));
assertThat(bottleRepository.countToxicByProducer(spisProducer), is(equalTo(1l)));
assertThat(bottleRepository.countNotToxicByProducer(bozkovProducer), is(equalTo(1l)));
assertThat(bottleRepository.countNotToxicByProducer(spisProducer), is(equalTo(1l)));
assertThat(bottleRepository.countToxicByStore(brnenka), is(equalTo(1l)));
assertThat(bottleRepository.countToxicByStore(tesco), is(equalTo(1l)));
}
}
|
apache-2.0
|
riganti/dotvvm
|
src/Framework/Core/Controls/Options/RowInsertOptions.cs
|
524
|
namespace DotVVM.Framework.Controls
{
/// <summary>
/// Represents settings for row (item) insert feature.
/// </summary>
/// <typeparam name="T">The type of inserted row.</typeparam>
public class RowInsertOptions<T> : IRowInsertOptions<T> where T : class, new()
{
/// <summary>
/// Gets or sets the row to be inserted to data source.
/// </summary>
public T? InsertedRow { get; set; }
object? IRowInsertOptions.InsertedRow => InsertedRow;
}
}
|
apache-2.0
|
ampproject/amp-toolbox-php
|
src/Validator/Spec/Tag/ScriptAmpReachPlayer.php
|
1923
|
<?php
/**
* DO NOT EDIT!
* This file was automatically generated via bin/generate-validator-spec.php.
*/
namespace AmpProject\Validator\Spec\Tag;
use AmpProject\Format;
use AmpProject\Html\Tag as Element;
use AmpProject\Validator\Spec\AttributeList;
use AmpProject\Validator\Spec\Identifiable;
use AmpProject\Validator\Spec\SpecRule;
use AmpProject\Validator\Spec\Tag;
use AmpProject\Validator\Spec\TagWithExtensionSpec;
/**
* Tag class ScriptAmpReachPlayer.
*
* @package ampproject/amp-toolbox.
*
* @property-read string $tagName
* @property-read array<string> $attrLists
* @property-read array<string> $htmlFormat
* @property-read string $extensionSpec
*/
final class ScriptAmpReachPlayer extends TagWithExtensionSpec implements Identifiable
{
/**
* ID of the tag.
*
* @var string
*/
const ID = 'SCRIPT [amp-reach-player]';
/**
* Array of extension spec rules.
*
* @var array
*/
const EXTENSION_SPEC = [
SpecRule::NAME => 'amp-reach-player',
SpecRule::VERSION => [
'0.1',
'latest',
],
SpecRule::DEPRECATED_ALLOW_DUPLICATES => true,
SpecRule::REQUIRES_USAGE => 'EXEMPTED',
];
/**
* Latest version of the extension.
*
* @var string
*/
const LATEST_VERSION = '0.1';
/**
* Meta data about the specific versions.
*
* @var array
*/
const VERSIONS_META = [
'0.1' => [
'hasCss' => false,
'hasBento' => false,
],
];
/**
* Array of spec rules.
*
* @var array
*/
const SPEC = [
SpecRule::TAG_NAME => Element::SCRIPT,
SpecRule::ATTR_LISTS => [
AttributeList\CommonExtensionAttrs::ID,
],
SpecRule::HTML_FORMAT => [
Format::AMP,
],
SpecRule::EXTENSION_SPEC => self::EXTENSION_SPEC,
];
}
|
apache-2.0
|
jentfoo/aws-sdk-java
|
aws-java-sdk-cloudfront/src/main/java/com/amazonaws/services/cloudfront/model/PublicKeySummary.java
|
9374
|
/*
* Copyright 2014-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.cloudfront.model;
import java.io.Serializable;
import javax.annotation.Generated;
/**
* <p>
* A complex data type for public key information.
* </p>
*
* @see <a href="http://docs.aws.amazon.com/goto/WebAPI/cloudfront-2019-03-26/PublicKeySummary" target="_top">AWS API
* Documentation</a>
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class PublicKeySummary implements Serializable, Cloneable {
/**
* <p>
* ID for public key information summary.
* </p>
*/
private String id;
/**
* <p>
* Name for public key information summary.
* </p>
*/
private String name;
/**
* <p>
* Creation time for public key information summary.
* </p>
*/
private java.util.Date createdTime;
/**
* <p>
* Encoded key for public key information summary.
* </p>
*/
private String encodedKey;
/**
* <p>
* Comment for public key information summary.
* </p>
*/
private String comment;
/**
* <p>
* ID for public key information summary.
* </p>
*
* @param id
* ID for public key information summary.
*/
public void setId(String id) {
this.id = id;
}
/**
* <p>
* ID for public key information summary.
* </p>
*
* @return ID for public key information summary.
*/
public String getId() {
return this.id;
}
/**
* <p>
* ID for public key information summary.
* </p>
*
* @param id
* ID for public key information summary.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public PublicKeySummary withId(String id) {
setId(id);
return this;
}
/**
* <p>
* Name for public key information summary.
* </p>
*
* @param name
* Name for public key information summary.
*/
public void setName(String name) {
this.name = name;
}
/**
* <p>
* Name for public key information summary.
* </p>
*
* @return Name for public key information summary.
*/
public String getName() {
return this.name;
}
/**
* <p>
* Name for public key information summary.
* </p>
*
* @param name
* Name for public key information summary.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public PublicKeySummary withName(String name) {
setName(name);
return this;
}
/**
* <p>
* Creation time for public key information summary.
* </p>
*
* @param createdTime
* Creation time for public key information summary.
*/
public void setCreatedTime(java.util.Date createdTime) {
this.createdTime = createdTime;
}
/**
* <p>
* Creation time for public key information summary.
* </p>
*
* @return Creation time for public key information summary.
*/
public java.util.Date getCreatedTime() {
return this.createdTime;
}
/**
* <p>
* Creation time for public key information summary.
* </p>
*
* @param createdTime
* Creation time for public key information summary.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public PublicKeySummary withCreatedTime(java.util.Date createdTime) {
setCreatedTime(createdTime);
return this;
}
/**
* <p>
* Encoded key for public key information summary.
* </p>
*
* @param encodedKey
* Encoded key for public key information summary.
*/
public void setEncodedKey(String encodedKey) {
this.encodedKey = encodedKey;
}
/**
* <p>
* Encoded key for public key information summary.
* </p>
*
* @return Encoded key for public key information summary.
*/
public String getEncodedKey() {
return this.encodedKey;
}
/**
* <p>
* Encoded key for public key information summary.
* </p>
*
* @param encodedKey
* Encoded key for public key information summary.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public PublicKeySummary withEncodedKey(String encodedKey) {
setEncodedKey(encodedKey);
return this;
}
/**
* <p>
* Comment for public key information summary.
* </p>
*
* @param comment
* Comment for public key information summary.
*/
public void setComment(String comment) {
this.comment = comment;
}
/**
* <p>
* Comment for public key information summary.
* </p>
*
* @return Comment for public key information summary.
*/
public String getComment() {
return this.comment;
}
/**
* <p>
* Comment for public key information summary.
* </p>
*
* @param comment
* Comment for public key information summary.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public PublicKeySummary withComment(String comment) {
setComment(comment);
return this;
}
/**
* Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
* redacted from this string using a placeholder value.
*
* @return A string representation of this object.
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (getId() != null)
sb.append("Id: ").append(getId()).append(",");
if (getName() != null)
sb.append("Name: ").append(getName()).append(",");
if (getCreatedTime() != null)
sb.append("CreatedTime: ").append(getCreatedTime()).append(",");
if (getEncodedKey() != null)
sb.append("EncodedKey: ").append(getEncodedKey()).append(",");
if (getComment() != null)
sb.append("Comment: ").append(getComment());
sb.append("}");
return sb.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (obj instanceof PublicKeySummary == false)
return false;
PublicKeySummary other = (PublicKeySummary) obj;
if (other.getId() == null ^ this.getId() == null)
return false;
if (other.getId() != null && other.getId().equals(this.getId()) == false)
return false;
if (other.getName() == null ^ this.getName() == null)
return false;
if (other.getName() != null && other.getName().equals(this.getName()) == false)
return false;
if (other.getCreatedTime() == null ^ this.getCreatedTime() == null)
return false;
if (other.getCreatedTime() != null && other.getCreatedTime().equals(this.getCreatedTime()) == false)
return false;
if (other.getEncodedKey() == null ^ this.getEncodedKey() == null)
return false;
if (other.getEncodedKey() != null && other.getEncodedKey().equals(this.getEncodedKey()) == false)
return false;
if (other.getComment() == null ^ this.getComment() == null)
return false;
if (other.getComment() != null && other.getComment().equals(this.getComment()) == false)
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int hashCode = 1;
hashCode = prime * hashCode + ((getId() == null) ? 0 : getId().hashCode());
hashCode = prime * hashCode + ((getName() == null) ? 0 : getName().hashCode());
hashCode = prime * hashCode + ((getCreatedTime() == null) ? 0 : getCreatedTime().hashCode());
hashCode = prime * hashCode + ((getEncodedKey() == null) ? 0 : getEncodedKey().hashCode());
hashCode = prime * hashCode + ((getComment() == null) ? 0 : getComment().hashCode());
return hashCode;
}
@Override
public PublicKeySummary clone() {
try {
return (PublicKeySummary) super.clone();
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
}
}
}
|
apache-2.0
|
manastech/ruby-openid
|
test/test_server.rb
|
87182
|
require 'test/unit'
require 'testutil'
require 'util'
require 'uri'
require 'openid/server'
require 'openid/cryptutil'
require 'openid/association'
require 'openid/util'
require 'openid/message'
require 'openid/store/memory'
require 'openid/dh'
require 'openid/consumer/associationmanager'
# In general, if you edit or add tests here, try to move in the
# direction of testing smaller units. For testing the external
# interfaces, we'll be developing an implementation-agnostic testing
# suite.
# for more, see /etc/ssh/moduli
module OpenID
ALT_MODULUS = 0xCAADDDEC1667FC68B5FA15D53C4E1532DD24561A1A2D47A12C01ABEA1E00731F6921AAC40742311FDF9E634BB7131BEE1AF240261554389A910425E044E88C8359B010F5AD2B80E29CB1A5B027B19D9E01A6F63A6F45E5D7ED2FF6A2A0085050A7D0CF307C3DB51D2490355907B4427C23A98DF1EB8ABEF2BA209BB7AFFE86A7
ALT_GEN = 5
class CatchLogs
def catchlogs_setup
@old_logger = Util.logger
Util.logger = self.method('got_log_message')
@messages = []
end
def got_log_message(message)
@messages << message
end
def teardown
Util.logger = @old_logger
end
end
class TestProtocolError < Test::Unit::TestCase
def test_browserWithReturnTo
return_to = "http://rp.unittest/consumer"
# will be a ProtocolError raised by Decode or
# CheckIDRequest.answer
args = Message.from_post_args({
'openid.mode' => 'monkeydance',
'openid.identity' => 'http://wagu.unittest/',
'openid.return_to' => return_to,
})
e = Server::ProtocolError.new(args, "plucky")
assert(e.has_return_to)
expected_args = {
'openid.mode' => 'error',
'openid.error' => 'plucky',
}
_, result_args = e.encode_to_url.split('?', 2)
result_args = Util.parse_query(result_args)
assert_equal(result_args, expected_args)
end
def test_browserWithReturnTo_OpenID2_GET
return_to = "http://rp.unittest/consumer"
# will be a ProtocolError raised by Decode or
# CheckIDRequest.answer
args = Message.from_post_args({
'openid.ns' => OPENID2_NS,
'openid.mode' => 'monkeydance',
'openid.identity' => 'http://wagu.unittest/',
'openid.claimed_id' => 'http://wagu.unittest/',
'openid.return_to' => return_to,
})
e = Server::ProtocolError.new(args, "plucky")
assert(e.has_return_to)
expected_args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'error',
'openid.error' => 'plucky',
}
_, result_args = e.encode_to_url.split('?', 2)
result_args = Util.parse_query(result_args)
assert_equal(result_args, expected_args)
end
def test_browserWithReturnTo_OpenID2_POST
return_to = "http://rp.unittest/consumer" + ('x' * OPENID1_URL_LIMIT)
# will be a ProtocolError raised by Decode or
# CheckIDRequest.answer
args = Message.from_post_args({
'openid.ns' => OPENID2_NS,
'openid.mode' => 'monkeydance',
'openid.identity' => 'http://wagu.unittest/',
'openid.claimed_id' => 'http://wagu.unittest/',
'openid.return_to' => return_to,
})
e = Server::ProtocolError.new(args, "plucky")
assert(e.has_return_to)
assert(e.which_encoding == Server::ENCODE_HTML_FORM)
assert(e.to_form_markup == e.to_message.to_form_markup(
args.get_arg(OPENID_NS, 'return_to')))
end
def test_browserWithReturnTo_OpenID1_exceeds_limit
return_to = "http://rp.unittest/consumer" + ('x' * OPENID1_URL_LIMIT)
# will be a ProtocolError raised by Decode or
# CheckIDRequest.answer
args = Message.from_post_args({
'openid.mode' => 'monkeydance',
'openid.identity' => 'http://wagu.unittest/',
'openid.return_to' => return_to,
})
e = Server::ProtocolError.new(args, "plucky")
assert(e.has_return_to)
expected_args = {
'openid.mode' => 'error',
'openid.error' => 'plucky',
}
assert(e.which_encoding == Server::ENCODE_URL)
_, result_args = e.encode_to_url.split('?', 2)
result_args = Util.parse_query(result_args)
assert_equal(result_args, expected_args)
end
def test_noReturnTo
# will be a ProtocolError raised by Decode or
# CheckIDRequest.answer
args = Message.from_post_args({
'openid.mode' => 'zebradance',
'openid.identity' => 'http://wagu.unittest/',
})
e = Server::ProtocolError.new(args, "waffles")
assert(!e.has_return_to)
expected = "error:waffles\nmode:error\n"
assert_equal(e.encode_to_kvform, expected)
end
def test_no_message
e = Server::ProtocolError.new(nil, "no message")
assert(e.get_return_to.nil?)
assert_equal(e.which_encoding, nil)
end
def test_which_encoding_no_message
e = Server::ProtocolError.new(nil, "no message")
assert(e.which_encoding.nil?)
end
end
class TestDecode < Test::Unit::TestCase
def setup
@claimed_id = 'http://de.legating.de.coder.unittest/'
@id_url = "http://decoder.am.unittest/"
@rt_url = "http://rp.unittest/foobot/?qux=zam"
@tr_url = "http://rp.unittest/"
@assoc_handle = "{assoc}{handle}"
@op_endpoint = 'http://endpoint.unittest/encode'
@store = Store::Memory.new()
@server = Server::Server.new(@store, @op_endpoint)
@decode = Server::Decoder.new(@server).method('decode')
end
def test_none
args = {}
r = @decode.call(args)
assert_equal(r, nil)
end
def test_irrelevant
args = {
'pony' => 'spotted',
'sreg.mutant_power' => 'decaffinator',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_bad
args = {
'openid.mode' => 'twos-compliment',
'openid.pants' => 'zippered',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_dictOfLists
args = {
'openid.mode' => ['checkid_setup'],
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.trust_root' => @tr_url,
}
begin
result = @decode.call(args)
rescue ArgumentError => err
assert !err.to_s.index('values').nil?
else
flunk("Expected ArgumentError, but got result #{result}")
end
end
def test_checkidImmediate
args = {
'openid.mode' => 'checkid_immediate',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.trust_root' => @tr_url,
# should be ignored
'openid.some.extension' => 'junk',
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckIDRequest))
assert_equal(r.mode, "checkid_immediate")
assert_equal(r.immediate, true)
assert_equal(r.identity, @id_url)
assert_equal(r.trust_root, @tr_url)
assert_equal(r.return_to, @rt_url)
assert_equal(r.assoc_handle, @assoc_handle)
end
def test_checkidImmediate_constructor
r = Server::CheckIDRequest.new(@id_url, @rt_url, nil,
@rt_url, true, @assoc_handle)
assert(r.mode == 'checkid_immediate')
assert(r.immediate)
end
def test_checkid_missing_return_to_and_trust_root
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.claimed_id' => @id_url,
'openid.assoc_handle' => @assoc_handle,
}
assert_raise(Server::ProtocolError) {
m = Message.from_post_args(args)
Server::CheckIDRequest.from_message(m, @op_endpoint)
}
end
def test_checkid_id_select
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => IDENTIFIER_SELECT,
'openid.claimed_id' => IDENTIFIER_SELECT,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.realm' => @tr_url,
}
m = Message.from_post_args(args)
req = Server::CheckIDRequest.from_message(m, @op_endpoint)
assert(req.id_select)
end
def test_checkid_not_id_select
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.realm' => @tr_url,
}
id_args = [
{'openid.claimed_id' => IDENTIFIER_SELECT,
'openid.identity' => 'http://bogus.com/'},
{'openid.claimed_id' => 'http://bogus.com/',
'openid.identity' => 'http://bogus.com/'},
]
id_args.each { |id|
m = Message.from_post_args(args.merge(id))
req = Server::CheckIDRequest.from_message(m, @op_endpoint)
assert(!req.id_select)
}
end
def test_checkidSetup
args = {
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.trust_root' => @tr_url,
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckIDRequest))
assert_equal(r.mode, "checkid_setup")
assert_equal(r.immediate, false)
assert_equal(r.identity, @id_url)
assert_equal(r.trust_root, @tr_url)
assert_equal(r.return_to, @rt_url)
end
def test_checkidSetupOpenID2
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.claimed_id' => @claimed_id,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.realm' => @tr_url,
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckIDRequest))
assert_equal(r.mode, "checkid_setup")
assert_equal(r.immediate, false)
assert_equal(r.identity, @id_url)
assert_equal(r.claimed_id, @claimed_id)
assert_equal(r.trust_root, @tr_url)
assert_equal(r.return_to, @rt_url)
end
def test_checkidSetupNoClaimedIDOpenID2
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.realm' => @tr_url,
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_checkidSetupNoIdentityOpenID2
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.realm' => @tr_url,
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckIDRequest))
assert_equal(r.mode, "checkid_setup")
assert_equal(r.immediate, false)
assert_equal(r.identity, nil)
assert_equal(r.trust_root, @tr_url)
assert_equal(r.return_to, @rt_url)
end
def test_checkidSetupNoReturnOpenID1
# Make sure an OpenID 1 request cannot be decoded if it lacks a
# return_to.
args = {
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.trust_root' => @tr_url,
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_checkidSetupNoReturnOpenID2
# Make sure an OpenID 2 request with no return_to can be decoded,
# and make sure a response to such a request raises
# NoReturnToError.
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.claimed_id' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.realm' => @tr_url,
}
req = @decode.call(args)
assert(req.is_a?(Server::CheckIDRequest))
assert_raise(Server::NoReturnToError) {
req.answer(false)
}
assert_raise(Server::NoReturnToError) {
req.encode_to_url('bogus')
}
assert_raise(Server::NoReturnToError) {
req.cancel_url
}
end
def test_checkidSetupRealmRequiredOpenID2
# Make sure that an OpenID 2 request which lacks return_to cannot
# be decoded if it lacks a realm. Spec => This value
# (openid.realm) MUST be sent if openid.return_to is omitted.
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_checkidSetupBadReturn
args = {
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => 'not a url',
}
begin
result = @decode.call(args)
rescue Server::ProtocolError => err
assert(err.openid_message)
else
flunk("Expected ProtocolError, instead returned with #{result}")
end
end
def test_checkidSetupUntrustedReturn
args = {
'openid.mode' => 'checkid_setup',
'openid.identity' => @id_url,
'openid.assoc_handle' => @assoc_handle,
'openid.return_to' => @rt_url,
'openid.trust_root' => 'http://not-the-return-place.unittest/',
}
begin
result = @decode.call(args)
rescue Server::UntrustedReturnURL => err
assert(err.openid_message, err.to_s)
else
flunk("Expected UntrustedReturnURL, instead returned with #{result}")
end
end
def test_checkidSetupUntrustedReturn_Constructor
assert_raise(Server::UntrustedReturnURL) {
Server::CheckIDRequest.new(@id_url, @rt_url, nil,
'http://not-the-return-place.unittest/',
false, @assoc_handle)
}
end
def test_checkidSetupMalformedReturnURL_Constructor
assert_raise(Server::MalformedReturnURL) {
Server::CheckIDRequest.new(@id_url, 'bogus://return.url', nil,
'http://trustroot.com/',
false, @assoc_handle)
}
end
def test_checkAuth
args = {
'openid.mode' => 'check_authentication',
'openid.assoc_handle' => '{dumb}{handle}',
'openid.sig' => 'sigblob',
'openid.signed' => 'identity,return_to,response_nonce,mode',
'openid.identity' => 'signedval1',
'openid.return_to' => 'signedval2',
'openid.response_nonce' => 'signedval3',
'openid.baz' => 'unsigned',
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckAuthRequest))
assert_equal(r.mode, 'check_authentication')
assert_equal(r.sig, 'sigblob')
end
def test_checkAuthMissingSignature
args = {
'openid.mode' => 'check_authentication',
'openid.assoc_handle' => '{dumb}{handle}',
'openid.signed' => 'foo,bar,mode',
'openid.foo' => 'signedval1',
'openid.bar' => 'signedval2',
'openid.baz' => 'unsigned',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_checkAuthAndInvalidate
args = {
'openid.mode' => 'check_authentication',
'openid.assoc_handle' => '{dumb}{handle}',
'openid.invalidate_handle' => '[[SMART_handle]]',
'openid.sig' => 'sigblob',
'openid.signed' => 'identity,return_to,response_nonce,mode',
'openid.identity' => 'signedval1',
'openid.return_to' => 'signedval2',
'openid.response_nonce' => 'signedval3',
'openid.baz' => 'unsigned',
}
r = @decode.call(args)
assert(r.is_a?(Server::CheckAuthRequest))
assert_equal(r.invalidate_handle, '[[SMART_handle]]')
end
def test_associateDH
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "Rzup9265tw==",
}
r = @decode.call(args)
assert(r.is_a?(Server::AssociateRequest))
assert_equal(r.mode, "associate")
assert_equal(r.session.session_type, "DH-SHA1")
assert_equal(r.assoc_type, "HMAC-SHA1")
assert(r.session.consumer_pubkey)
end
def test_associateDHMissingKey
# Trying DH assoc w/o public key
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
}
# Using DH-SHA1 without supplying dh_consumer_public is an error.
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_associateDHpubKeyNotB64
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "donkeydonkeydonkey",
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_associateDHModGen
# test dh with non-default but valid values for dh_modulus and
# dh_gen
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "Rzup9265tw==",
'openid.dh_modulus' => CryptUtil.num_to_base64(ALT_MODULUS),
'openid.dh_gen' => CryptUtil.num_to_base64(ALT_GEN) ,
}
r = @decode.call(args)
assert(r.is_a?(Server::AssociateRequest))
assert_equal(r.mode, "associate")
assert_equal(r.session.session_type, "DH-SHA1")
assert_equal(r.assoc_type, "HMAC-SHA1")
assert_equal(r.session.dh.modulus, ALT_MODULUS)
assert_equal(r.session.dh.generator, ALT_GEN)
assert(r.session.consumer_pubkey)
end
def test_associateDHCorruptModGen
# test dh with non-default but valid values for dh_modulus and
# dh_gen
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "Rzup9265tw==",
'openid.dh_modulus' => 'pizza',
'openid.dh_gen' => 'gnocchi',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_associateDHMissingGen
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "Rzup9265tw==",
'openid.dh_modulus' => 'pizza',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_associateDHMissingMod
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "Rzup9265tw==",
'openid.dh_gen' => 'pizza',
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
# def test_associateDHInvalidModGen(self):
# # test dh with properly encoded values that are not a valid
# # modulus/generator combination.
# args = {
# 'openid.mode': 'associate',
# 'openid.session_type': 'DH-SHA1',
# 'openid.dh_consumer_public': "Rzup9265tw==",
# 'openid.dh_modulus': cryptutil.longToBase64(9),
# 'openid.dh_gen': cryptutil.longToBase64(27) ,
# }
# self.failUnlessRaises(server.ProtocolError, self.decode, args)
# test_associateDHInvalidModGen.todo = "low-priority feature"
def test_associateWeirdSession
args = {
'openid.mode' => 'associate',
'openid.session_type' => 'FLCL6',
'openid.dh_consumer_public' => "YQ==\n",
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_associatePlain
args = {
'openid.mode' => 'associate',
}
r = @decode.call(args)
assert(r.is_a?(Server::AssociateRequest))
assert_equal(r.mode, "associate")
assert_equal(r.session.session_type, "no-encryption")
assert_equal(r.assoc_type, "HMAC-SHA1")
end
def test_nomode
args = {
'openid.session_type' => 'DH-SHA1',
'openid.dh_consumer_public' => "my public keeey",
}
assert_raise(Server::ProtocolError) {
@decode.call(args)
}
end
def test_invalidns
args = {'openid.ns' => 'Vegetables',
'openid.mode' => 'associate'}
begin
@decode.call(args)
rescue Server::ProtocolError => err
assert(err.openid_message)
assert(err.to_s.index('Vegetables'))
end
end
end
class BogusEncoder < Server::Encoder
def encode(response)
return "BOGUS"
end
end
class BogusDecoder < Server::Decoder
def decode(query)
return "BOGUS"
end
end
class TestEncode < Test::Unit::TestCase
def setup
@encoder = Server::Encoder.new
@encode = @encoder.method('encode')
@op_endpoint = 'http://endpoint.unittest/encode'
@store = Store::Memory.new
@server = Server::Server.new(@store, @op_endpoint)
end
def test_id_res_OpenID2_GET
# Check that when an OpenID 2 response does not exceed the OpenID
# 1 message size, a GET response (i.e., redirect) is issued.
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false,
nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'ns' => OPENID2_NS,
'mode' => 'id_res',
'identity' => request.identity,
'claimed_id' => request.identity,
'return_to' => request.return_to,
})
assert(!response.render_as_form)
assert(response.which_encoding == Server::ENCODE_URL)
webresponse = @encode.call(response)
assert(webresponse.headers.member?('location'))
end
def test_id_res_OpenID2_POST
# Check that when an OpenID 2 response exceeds the OpenID 1
# message size, a POST response (i.e., an HTML form) is returned.
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false,
nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'ns' => OPENID2_NS,
'mode' => 'id_res',
'identity' => request.identity,
'claimed_id' => request.identity,
'return_to' => 'x' * OPENID1_URL_LIMIT,
})
assert(response.render_as_form)
assert(response.encode_to_url.length > OPENID1_URL_LIMIT)
assert(response.which_encoding == Server::ENCODE_HTML_FORM)
webresponse = @encode.call(response)
assert_equal(webresponse.body, response.to_form_markup)
end
def test_to_form_markup
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false,
nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'ns' => OPENID2_NS,
'mode' => 'id_res',
'identity' => request.identity,
'claimed_id' => request.identity,
'return_to' => 'x' * OPENID1_URL_LIMIT,
})
form_markup = response.to_form_markup({'foo'=>'bar'})
assert(/ foo="bar"/ =~ form_markup, form_markup)
end
def test_to_html
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false,
nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'ns' => OPENID2_NS,
'mode' => 'id_res',
'identity' => request.identity,
'claimed_id' => request.identity,
'return_to' => 'x' * OPENID1_URL_LIMIT,
})
html = response.to_html
assert(html)
end
def test_id_res_OpenID1_exceeds_limit
# Check that when an OpenID 1 response exceeds the OpenID 1
# message size, a GET response is issued. Technically, this
# shouldn't be permitted by the library, but this test is in place
# to preserve the status quo for OpenID 1.
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false,
nil)
request.message = Message.new(OPENID1_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'mode' => 'id_res',
'identity' => request.identity,
'return_to' => 'x' * OPENID1_URL_LIMIT,
})
assert(!response.render_as_form)
assert(response.encode_to_url.length > OPENID1_URL_LIMIT)
assert(response.which_encoding == Server::ENCODE_URL)
webresponse = @encode.call(response)
assert_equal(webresponse.headers['location'], response.encode_to_url)
end
def test_id_res
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false, nil)
request.message = Message.new(OPENID1_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'mode' => 'id_res',
'identity' => request.identity,
'return_to' => request.return_to,
})
webresponse = @encode.call(response)
assert_equal(webresponse.code, Server::HTTP_REDIRECT)
assert(webresponse.headers.member?('location'))
location = webresponse.headers['location']
assert(location.starts_with?(request.return_to),
sprintf("%s does not start with %s",
location, request.return_to))
# argh.
q2 = Util.parse_query(URI::parse(location).query)
expected = response.fields.to_post_args
assert_equal(q2, expected)
end
def test_cancel
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false, nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'mode' => 'cancel',
})
webresponse = @encode.call(response)
assert_equal(webresponse.code, Server::HTTP_REDIRECT)
assert(webresponse.headers.member?('location'))
end
def test_cancel_to_form
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false, nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'mode' => 'cancel',
})
form = response.to_form_markup
assert(form.index(request.return_to))
end
def test_assocReply
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID2_NS, 'session_type', 'no-encryption')
request = Server::AssociateRequest.from_message(msg)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_post_args(
{'openid.assoc_handle' => "every-zig"})
webresponse = @encode.call(response)
body = "assoc_handle:every-zig\n"
assert_equal(webresponse.code, Server::HTTP_OK)
assert_equal(webresponse.headers, {})
assert_equal(webresponse.body, body)
end
def test_checkauthReply
request = Server::CheckAuthRequest.new('a_sock_monkey',
'siggggg',
[])
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'is_valid' => 'true',
'invalidate_handle' => 'xXxX:xXXx'
})
body = "invalidate_handle:xXxX:xXXx\nis_valid:true\n"
webresponse = @encode.call(response)
assert_equal(webresponse.code, Server::HTTP_OK)
assert_equal(webresponse.headers, {})
assert_equal(webresponse.body, body)
end
def test_unencodableError
args = Message.from_post_args({
'openid.identity' => 'http://limu.unittest/',
})
e = Server::ProtocolError.new(args, "wet paint")
assert_raise(Server::EncodingError) {
@encode.call(e)
}
end
def test_encodableError
args = Message.from_post_args({
'openid.mode' => 'associate',
'openid.identity' => 'http://limu.unittest/',
})
body="error:snoot\nmode:error\n"
webresponse = @encode.call(Server::ProtocolError.new(args, "snoot"))
assert_equal(webresponse.code, Server::HTTP_ERROR)
assert_equal(webresponse.headers, {})
assert_equal(webresponse.body, body)
end
end
class TestSigningEncode < Test::Unit::TestCase
def setup
@_dumb_key = Server::Signatory._dumb_key
@_normal_key = Server::Signatory._normal_key
@store = Store::Memory.new()
@server = Server::Server.new(@store, "http://signing.unittest/enc")
@request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false, nil)
@request.message = Message.new(OPENID2_NS)
@response = Server::OpenIDResponse.new(@request)
@response.fields = Message.from_openid_args({
'mode' => 'id_res',
'identity' => @request.identity,
'return_to' => @request.return_to,
})
@signatory = Server::Signatory.new(@store)
@encoder = Server::SigningEncoder.new(@signatory)
@encode = @encoder.method('encode')
end
def test_idres
assoc_handle = '{bicycle}{shed}'
@store.store_association(
@_normal_key,
Association.from_expires_in(60, assoc_handle,
'sekrit', 'HMAC-SHA1'))
@request.assoc_handle = assoc_handle
webresponse = @encode.call(@response)
assert_equal(webresponse.code, Server::HTTP_REDIRECT)
assert(webresponse.headers.member?('location'))
location = webresponse.headers['location']
query = Util.parse_query(URI::parse(location).query)
assert(query.member?('openid.sig'))
assert(query.member?('openid.assoc_handle'))
assert(query.member?('openid.signed'))
end
def test_idresDumb
webresponse = @encode.call(@response)
assert_equal(webresponse.code, Server::HTTP_REDIRECT)
assert(webresponse.headers.has_key?('location'))
location = webresponse.headers['location']
query = Util.parse_query(URI::parse(location).query)
assert(query.member?('openid.sig'))
assert(query.member?('openid.assoc_handle'))
assert(query.member?('openid.signed'))
end
def test_forgotStore
@encoder.signatory = nil
assert_raise(ArgumentError) {
@encode.call(@response)
}
end
def test_cancel
request = Server::CheckIDRequest.new(
'http://bombom.unittest/',
'http://burr.unittest/999',
@server.op_endpoint,
'http://burr.unittest/',
false, nil)
request.message = Message.new(OPENID2_NS)
response = Server::OpenIDResponse.new(request)
response.fields.set_arg(OPENID_NS, 'mode', 'cancel')
webresponse = @encode.call(response)
assert_equal(webresponse.code, Server::HTTP_REDIRECT)
assert(webresponse.headers.has_key?('location'))
location = webresponse.headers['location']
query = Util.parse_query(URI::parse(location).query)
assert !query.has_key?('openid.sig')
end
def test_assocReply
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID2_NS, 'session_type', 'no-encryption')
request = Server::AssociateRequest.from_message(msg)
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({'assoc_handle' => "every-zig"})
webresponse = @encode.call(response)
body = "assoc_handle:every-zig\n"
assert_equal(webresponse.code, Server::HTTP_OK)
assert_equal(webresponse.headers, {})
assert_equal(webresponse.body, body)
end
def test_alreadySigned
@response.fields.set_arg(OPENID_NS, 'sig', 'priorSig==')
assert_raise(Server::AlreadySigned) {
@encode.call(@response)
}
end
end
class TestCheckID < Test::Unit::TestCase
def setup
@op_endpoint = 'http://endpoint.unittest/'
@store = Store::Memory.new()
@server = Server::Server.new(@store, @op_endpoint)
@request = Server::CheckIDRequest.new(
'http://bambam.unittest/',
'http://bar.unittest/999',
@server.op_endpoint,
'http://bar.unittest/',
false)
@request.message = Message.new(OPENID2_NS)
end
def test_trustRootInvalid
@request.trust_root = "http://foo.unittest/17"
@request.return_to = "http://foo.unittest/39"
assert(!@request.trust_root_valid())
end
def test_trustRootInvalid_modified
@request.trust_root = "does://not.parse/"
@request.message = :sentinel
begin
result = @request.trust_root_valid
rescue Server::MalformedTrustRoot => why
assert_equal(:sentinel, why.openid_message)
else
flunk("Expected MalformedTrustRoot, got #{result.inspect}")
end
end
def test_trustRootvalid_absent_trust_root
@request.trust_root = nil
assert(@request.trust_root_valid())
end
def test_trustRootValid
@request.trust_root = "http://foo.unittest/"
@request.return_to = "http://foo.unittest/39"
assert(@request.trust_root_valid())
end
def test_trustRootValidNoReturnTo
request = Server::CheckIDRequest.new(
'http://bambam.unittest/',
nil,
@server.op_endpoint,
'http://bar.unittest/',
false)
assert(request.trust_root_valid())
end
def test_returnToVerified_callsVerify
# Make sure that verifyReturnTo is calling the trustroot
# function verifyReturnTo
# Ensure that exceptions are passed through
sentinel = Exception.new()
__req = @request
tc = self
vrfyExc = Proc.new { |trust_root, return_to|
tc.assert_equal(__req.trust_root, trust_root)
tc.assert_equal(__req.return_to, return_to)
raise sentinel
}
TrustRoot.extend(OverrideMethodMixin)
TrustRoot.with_method_overridden(:verify_return_to, vrfyExc) do
begin
@request.return_to_verified()
flunk("Expected sentinel to be raised, got success")
rescue Exception => e
assert(e.equal?(sentinel), [e, sentinel].inspect)
end
end
# Ensure that True and False are passed through unchanged
constVerify = Proc.new { |val|
verify = Proc.new { |trust_root, return_to|
tc.assert_equal(__req.trust_root, trust_root)
tc.assert_equal(__req.request.return_to, return_to)
return val
}
return verify
}
[true, false].each { |val|
verifier = constVerify.call(val)
TrustRoot.with_method_overridden(:verify_return_to, verifier) do
assert_equal(val, @request.return_to_verified())
end
}
end
def _expectAnswer(answer, identity=nil, claimed_id=nil)
expected_list = [
['mode', 'id_res'],
['return_to', @request.return_to],
['op_endpoint', @op_endpoint],
]
if identity
expected_list << ['identity', identity]
if claimed_id
expected_list << ['claimed_id', claimed_id]
else
expected_list << ['claimed_id', identity]
end
end
expected_list.each { |k, expected|
actual = answer.fields.get_arg(OPENID_NS, k)
assert_equal(expected, actual,
sprintf("%s: expected %s, got %s",
k, expected, actual))
}
assert(answer.fields.has_key?(OPENID_NS, 'response_nonce'))
assert(answer.fields.get_openid_namespace() == OPENID2_NS)
# One for nonce, one for ns
assert_equal(answer.fields.to_post_args.length,
expected_list.length + 2,
answer.fields.to_post_args.inspect)
end
def test_answerAllow
# Check the fields specified by "Positive Assertions"
#
# including mode=id_res, identity, claimed_id, op_endpoint,
# return_to
answer = @request.answer(true)
assert_equal(answer.request, @request)
_expectAnswer(answer, @request.identity)
end
def test_answerAllowDelegatedIdentity
@request.claimed_id = 'http://delegating.unittest/'
answer = @request.answer(true)
_expectAnswer(answer, @request.identity,
@request.claimed_id)
end
def test_answerAllowWithoutIdentityReally
@request.identity = nil
answer = @request.answer(true)
assert_equal(answer.request, @request)
_expectAnswer(answer)
end
def test_answerAllowAnonymousFail
@request.identity = nil
# XXX - Check on this, I think this behavior is legal in OpenID
# 2.0?
assert_raise(ArgumentError) {
@request.answer(true, nil, "=V")
}
end
def test_answerAllowWithIdentity
@request.identity = IDENTIFIER_SELECT
selected_id = 'http://anon.unittest/9861'
answer = @request.answer(true, nil, selected_id)
_expectAnswer(answer, selected_id)
end
def test_answerAllowWithNoIdentity
@request.identity = IDENTIFIER_SELECT
assert_raise(ArgumentError) {
@request.answer(true, nil, nil)
}
end
def test_immediate_openid1_no_identity
@request.message = Message.new(OPENID1_NS)
@request.immediate = true
@request.mode = 'checkid_immediate'
resp = @request.answer(false)
assert(resp.fields.get_arg(OPENID_NS, 'mode') == 'id_res')
end
def test_checkid_setup_openid1_no_identity
@request.message = Message.new(OPENID1_NS)
@request.immediate = false
@request.mode = 'checkid_setup'
resp = @request.answer(false)
assert(resp.fields.get_arg(OPENID_NS, 'mode') == 'cancel')
end
def test_immediate_openid1_no_server_url
@request.message = Message.new(OPENID1_NS)
@request.immediate = true
@request.mode = 'checkid_immediate'
@request.op_endpoint = nil
assert_raise(ArgumentError) {
@request.answer(false)
}
end
def test_immediate_encode_to_url
@request.message = Message.new(OPENID1_NS)
@request.immediate = true
@request.mode = 'checkid_immediate'
@request.trust_root = "BOGUS"
@request.assoc_handle = "ASSOC"
server_url = "http://server.com/server"
url = @request.encode_to_url(server_url)
assert(url.starts_with?(server_url))
_, query = url.split("?", 2)
args = Util.parse_query(query)
m = Message.from_post_args(args)
assert(m.get_arg(OPENID_NS, 'trust_root') == "BOGUS")
assert(m.get_arg(OPENID_NS, 'assoc_handle') == "ASSOC")
assert(m.get_arg(OPENID_NS, 'mode'), "checkid_immediate")
assert(m.get_arg(OPENID_NS, 'identity') == @request.identity)
assert(m.get_arg(OPENID_NS, 'claimed_id') == @request.claimed_id)
assert(m.get_arg(OPENID_NS, 'return_to') == @request.return_to)
end
def test_answerAllowWithDelegatedIdentityOpenID2
# Answer an IDENTIFIER_SELECT case with a delegated identifier.
# claimed_id delegates to selected_id here.
@request.identity = IDENTIFIER_SELECT
selected_id = 'http://anon.unittest/9861'
claimed_id = 'http://monkeyhat.unittest/'
answer = @request.answer(true, nil, selected_id, claimed_id)
_expectAnswer(answer, selected_id, claimed_id)
end
def test_answerAllowWithDelegatedIdentityOpenID1
# claimed_id parameter doesn't exist in OpenID 1.
@request.message = Message.new(OPENID1_NS)
# claimed_id delegates to selected_id here.
@request.identity = IDENTIFIER_SELECT
selected_id = 'http://anon.unittest/9861'
claimed_id = 'http://monkeyhat.unittest/'
assert_raise(Server::VersionError) {
@request.answer(true, nil, selected_id, claimed_id)
}
end
def test_answerAllowWithAnotherIdentity
# XXX - Check on this, I think this behavior is legal in OpenID
# 2.0?
assert_raise(ArgumentError){
@request.answer(true, nil, "http://pebbles.unittest/")
}
end
def test_answerAllowNoIdentityOpenID1
@request.message = Message.new(OPENID1_NS)
@request.identity = nil
assert_raise(ArgumentError) {
@request.answer(true, nil, nil)
}
end
def test_answerAllowForgotEndpoint
@request.op_endpoint = nil
assert_raise(RuntimeError) {
@request.answer(true)
}
end
def test_checkIDWithNoIdentityOpenID1
msg = Message.new(OPENID1_NS)
msg.set_arg(OPENID_NS, 'return_to', 'bogus')
msg.set_arg(OPENID_NS, 'trust_root', 'bogus')
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
assert_raise(Server::ProtocolError) {
Server::CheckIDRequest.from_message(msg, @server)
}
end
def test_fromMessageClaimedIDWithoutIdentityOpenID2
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'return_to', 'http://invalid:8000/rt')
msg.set_arg(OPENID_NS, 'claimed_id', 'https://example.myopenid.com')
assert_raise(Server::ProtocolError) {
Server::CheckIDRequest.from_message(msg, @server)
}
end
def test_fromMessageIdentityWithoutClaimedIDOpenID2
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'return_to', 'http://invalid:8000/rt')
msg.set_arg(OPENID_NS, 'identity', 'https://example.myopenid.com')
assert_raise(Server::ProtocolError) {
Server::CheckIDRequest.from_message(msg, @server)
}
end
def test_fromMessageWithEmptyTrustRoot
return_to = 'http://some.url/foo?bar=baz'
msg = Message.from_post_args({
'openid.assoc_handle' => '{blah}{blah}{OZivdQ==}',
'openid.claimed_id' => 'http://delegated.invalid/',
'openid.identity' => 'http://op-local.example.com/',
'openid.mode' => 'checkid_setup',
'openid.ns' => 'http://openid.net/signon/1.0',
'openid.return_to' => return_to,
'openid.trust_root' => ''
});
result = Server::CheckIDRequest.from_message(msg, @server)
assert_equal(return_to, result.trust_root)
end
def test_trustRootOpenID1
# Ignore openid.realm in OpenID 1
msg = Message.new(OPENID1_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'trust_root', 'http://trustroot.com/')
msg.set_arg(OPENID_NS, 'realm', 'http://fake_trust_root/')
msg.set_arg(OPENID_NS, 'return_to', 'http://trustroot.com/foo')
msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
msg.set_arg(OPENID_NS, 'identity', 'george')
result = Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
assert(result.trust_root == 'http://trustroot.com/')
end
def test_trustRootOpenID2
# Ignore openid.trust_root in OpenID 2
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'realm', 'http://trustroot.com/')
msg.set_arg(OPENID_NS, 'trust_root', 'http://fake_trust_root/')
msg.set_arg(OPENID_NS, 'return_to', 'http://trustroot.com/foo')
msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
msg.set_arg(OPENID_NS, 'identity', 'george')
msg.set_arg(OPENID_NS, 'claimed_id', 'george')
result = Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
assert(result.trust_root == 'http://trustroot.com/')
end
def test_answerAllowNoTrustRoot
@request.trust_root = nil
answer = @request.answer(true)
assert_equal(answer.request, @request)
_expectAnswer(answer, @request.identity)
end
def test_answerImmediateDenyOpenID2
# Look for mode=setup_needed in checkid_immediate negative
# response in OpenID 2 case.
#
# See specification Responding to Authentication Requests /
# Negative Assertions / In Response to Immediate Requests.
@request.mode = 'checkid_immediate'
@request.immediate = true
server_url = "http://setup-url.unittest/"
# crappiting setup_url, you dirty my interface with your presence!
answer = @request.answer(false, server_url)
assert_equal(answer.request, @request)
assert_equal(answer.fields.to_post_args.length, 3, answer.fields)
assert_equal(answer.fields.get_openid_namespace, OPENID2_NS)
assert_equal(answer.fields.get_arg(OPENID_NS, 'mode'),
'setup_needed')
# user_setup_url no longer required.
end
def test_answerImmediateDenyOpenID1
# Look for user_setup_url in checkid_immediate negative response
# in OpenID 1 case.
@request.message = Message.new(OPENID1_NS)
@request.mode = 'checkid_immediate'
@request.immediate = true
@request.claimed_id = 'http://claimed-id.test/'
server_url = "http://setup-url.unittest/"
# crappiting setup_url, you dirty my interface with your presence!
answer = @request.answer(false, server_url)
assert_equal(answer.request, @request)
assert_equal(2, answer.fields.to_post_args.length, answer.fields)
assert_equal(OPENID1_NS, answer.fields.get_openid_namespace)
assert_equal('id_res', answer.fields.get_arg(OPENID_NS, 'mode'))
usu = answer.fields.get_arg(OPENID_NS, 'user_setup_url', '')
assert(usu.starts_with?(server_url))
expected_substr = 'openid.claimed_id=http%3A%2F%2Fclaimed-id.test%2F'
assert(!usu.index(expected_substr).nil?, usu)
end
def test_answerSetupDeny
answer = @request.answer(false)
assert_equal(answer.fields.get_args(OPENID_NS), {
'mode' => 'cancel',
})
end
def test_encodeToURL
server_url = 'http://openid-server.unittest/'
result = @request.encode_to_url(server_url)
# How to check? How about a round-trip test.
_, result_args = result.split('?', 2)
result_args = Util.parse_query(result_args)
message = Message.from_post_args(result_args)
rebuilt_request = Server::CheckIDRequest.from_message(message,
@server.op_endpoint)
@request.message = message
@request.instance_variables.each { |var|
assert_equal(@request.instance_variable_get(var),
rebuilt_request.instance_variable_get(var), var)
}
end
def test_getCancelURL
url = @request.cancel_url
rt, query_string = url.split('?', -1)
assert_equal(@request.return_to, rt)
query = Util.parse_query(query_string)
assert_equal(query, {'openid.mode' => 'cancel',
'openid.ns' => OPENID2_NS})
end
def test_getCancelURLimmed
@request.mode = 'checkid_immediate'
@request.immediate = true
assert_raise(ArgumentError) {
@request.cancel_url
}
end
def test_fromMessageWithoutTrustRoot
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'return_to', 'http://real.trust.root/foo')
msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
msg.set_arg(OPENID_NS, 'identity', 'george')
msg.set_arg(OPENID_NS, 'claimed_id', 'george')
result = Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
assert_equal(result.trust_root, 'http://real.trust.root/foo')
end
def test_fromMessageWithoutTrustRootOrReturnTo
msg = Message.new(OPENID2_NS)
msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
msg.set_arg(OPENID_NS, 'identity', 'george')
msg.set_arg(OPENID_NS, 'claimed_id', 'george')
assert_raises(Server::ProtocolError) {
Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
}
end
end
class TestCheckIDExtension < Test::Unit::TestCase
def setup
@op_endpoint = 'http://endpoint.unittest/ext'
@store = Store::Memory.new()
@server = Server::Server.new(@store, @op_endpoint)
@request = Server::CheckIDRequest.new(
'http://bambam.unittest/',
'http://bar.unittest/999',
@server.op_endpoint,
'http://bar.unittest/',
false)
@request.message = Message.new(OPENID2_NS)
@response = Server::OpenIDResponse.new(@request)
@response.fields.set_arg(OPENID_NS, 'mode', 'id_res')
@response.fields.set_arg(OPENID_NS, 'blue', 'star')
end
def test_addField
namespace = 'something:'
@response.fields.set_arg(namespace, 'bright', 'potato')
assert_equal(@response.fields.get_args(OPENID_NS),
{'blue' => 'star',
'mode' => 'id_res',
})
assert_equal(@response.fields.get_args(namespace),
{'bright' => 'potato'})
end
def test_addFields
namespace = 'mi5:'
args = {'tangy' => 'suspenders',
'bravo' => 'inclusion'}
@response.fields.update_args(namespace, args)
assert_equal(@response.fields.get_args(OPENID_NS),
{'blue' => 'star',
'mode' => 'id_res',
})
assert_equal(@response.fields.get_args(namespace), args)
end
end
class MockSignatory
attr_accessor :isValid, :assocs
def initialize(assoc)
@isValid = true
@assocs = [assoc]
end
def verify(assoc_handle, message)
Util.assert(message.has_key?(OPENID_NS, "sig"))
if self.assocs.member?([true, assoc_handle])
return @isValid
else
return false
end
end
def get_association(assoc_handle, dumb)
if self.assocs.member?([dumb, assoc_handle])
# This isn't a valid implementation for many uses of this
# function, mind you.
return true
else
return nil
end
end
def invalidate(assoc_handle, dumb)
if self.assocs.member?([dumb, assoc_handle])
@assocs.delete([dumb, assoc_handle])
end
end
end
class TestCheckAuth < Test::Unit::TestCase
def setup
@assoc_handle = 'mooooooooo'
@message = Message.from_post_args({
'openid.sig' => 'signarture',
'one' => 'alpha',
'two' => 'beta',
})
@request = Server::CheckAuthRequest.new(
@assoc_handle, @message)
@request.message = Message.new(OPENID2_NS)
@signatory = MockSignatory.new([true, @assoc_handle])
end
def test_to_s
@request.to_s
end
def test_valid
r = @request.answer(@signatory)
assert_equal({'is_valid' => 'true'},
r.fields.get_args(OPENID_NS))
assert_equal(r.request, @request)
end
def test_invalid
@signatory.isValid = false
r = @request.answer(@signatory)
assert_equal({'is_valid' => 'false'},
r.fields.get_args(OPENID_NS))
end
def test_replay
# Don't validate the same response twice.
#
# From "Checking the Nonce"::
#
# When using "check_authentication", the OP MUST ensure that an
# assertion has not yet been accepted with the same value for
# "openid.response_nonce".
#
# In this implementation, the assoc_handle is only valid once.
# And nonces are a signed component of the message, so they can't
# be used with another handle without breaking the sig.
r = @request.answer(@signatory)
r = @request.answer(@signatory)
assert_equal({'is_valid' => 'false'},
r.fields.get_args(OPENID_NS))
end
def test_invalidatehandle
@request.invalidate_handle = "bogusHandle"
r = @request.answer(@signatory)
assert_equal(r.fields.get_args(OPENID_NS),
{'is_valid' => 'true',
'invalidate_handle' => "bogusHandle"})
assert_equal(r.request, @request)
end
def test_invalidatehandleNo
assoc_handle = 'goodhandle'
@signatory.assocs << [false, 'goodhandle']
@request.invalidate_handle = assoc_handle
r = @request.answer(@signatory)
assert_equal(r.fields.get_args(OPENID_NS), {'is_valid' => 'true'})
end
end
class TestAssociate < Test::Unit::TestCase
# TODO: test DH with non-default values for modulus and gen.
# (important to do because we actually had it broken for a while.)
def setup
@request = Server::AssociateRequest.from_message(Message.from_post_args({}))
@store = Store::Memory.new()
@signatory = Server::Signatory.new(@store)
end
def test_dhSHA1
@assoc = @signatory.create_association(false, 'HMAC-SHA1')
consumer_dh = DiffieHellman.from_defaults()
cpub = consumer_dh.public
server_dh = DiffieHellman.from_defaults()
session = Server::DiffieHellmanSHA1ServerSession.new(server_dh, cpub)
@request = Server::AssociateRequest.new(session, 'HMAC-SHA1')
@request.message = Message.new(OPENID2_NS)
response = @request.answer(@assoc)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
assert_equal(rfg.call("assoc_handle"), @assoc.handle)
assert(!rfg.call("mac_key"))
assert_equal(rfg.call("session_type"), "DH-SHA1")
assert(rfg.call("enc_mac_key"))
assert(rfg.call("dh_server_public"))
enc_key = Util.from_base64(rfg.call("enc_mac_key"))
spub = CryptUtil.base64_to_num(rfg.call("dh_server_public"))
secret = consumer_dh.xor_secret(CryptUtil.method('sha1'),
spub, enc_key)
assert_equal(secret, @assoc.secret)
end
def test_dhSHA256
@assoc = @signatory.create_association(false, 'HMAC-SHA256')
consumer_dh = DiffieHellman.from_defaults()
cpub = consumer_dh.public
server_dh = DiffieHellman.from_defaults()
session = Server::DiffieHellmanSHA256ServerSession.new(server_dh, cpub)
@request = Server::AssociateRequest.new(session, 'HMAC-SHA256')
@request.message = Message.new(OPENID2_NS)
response = @request.answer(@assoc)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call("assoc_type"), "HMAC-SHA256")
assert_equal(rfg.call("assoc_handle"), @assoc.handle)
assert(!rfg.call("mac_key"))
assert_equal(rfg.call("session_type"), "DH-SHA256")
assert(rfg.call("enc_mac_key"))
assert(rfg.call("dh_server_public"))
enc_key = Util.from_base64(rfg.call("enc_mac_key"))
spub = CryptUtil.base64_to_num(rfg.call("dh_server_public"))
secret = consumer_dh.xor_secret(CryptUtil.method('sha256'),
spub, enc_key)
assert_equal(secret, @assoc.secret)
end
def test_protoError256
s256_session = Consumer::DiffieHellmanSHA256Session.new()
invalid_s256 = {'openid.assoc_type' => 'HMAC-SHA1',
'openid.session_type' => 'DH-SHA256',}
invalid_s256.merge!(s256_session.get_request())
invalid_s256_2 = {'openid.assoc_type' => 'MONKEY-PIRATE',
'openid.session_type' => 'DH-SHA256',}
invalid_s256_2.merge!(s256_session.get_request())
bad_request_argss = [
invalid_s256,
invalid_s256_2,
]
bad_request_argss.each { |request_args|
message = Message.from_post_args(request_args)
assert_raise(Server::ProtocolError) {
Server::AssociateRequest.from_message(message)
}
}
end
def test_protoError
s1_session = Consumer::DiffieHellmanSHA1Session.new()
invalid_s1 = {'openid.assoc_type' => 'HMAC-SHA256',
'openid.session_type' => 'DH-SHA1',}
invalid_s1.merge!(s1_session.get_request())
invalid_s1_2 = {'openid.assoc_type' => 'ROBOT-NINJA',
'openid.session_type' => 'DH-SHA1',}
invalid_s1_2.merge!(s1_session.get_request())
bad_request_argss = [
{'openid.assoc_type' => 'Wha?'},
invalid_s1,
invalid_s1_2,
]
bad_request_argss.each { |request_args|
message = Message.from_post_args(request_args)
assert_raise(Server::ProtocolError) {
Server::AssociateRequest.from_message(message)
}
}
end
def test_protoErrorFields
contact = 'user@example.invalid'
reference = 'Trac ticket number MAX_INT'
error = 'poltergeist'
openid1_args = {
'openid.identitiy' => 'invalid',
'openid.mode' => 'checkid_setup',
}
openid2_args = openid1_args.dup
openid2_args.merge!({'openid.ns' => OPENID2_NS})
# Check presence of optional fields in both protocol versions
openid1_msg = Message.from_post_args(openid1_args)
p = Server::ProtocolError.new(openid1_msg, error,
reference, contact)
reply = p.to_message()
assert_equal(reply.get_arg(OPENID_NS, 'reference'), reference)
assert_equal(reply.get_arg(OPENID_NS, 'contact'), contact)
openid2_msg = Message.from_post_args(openid2_args)
p = Server::ProtocolError.new(openid2_msg, error,
reference, contact)
reply = p.to_message()
assert_equal(reply.get_arg(OPENID_NS, 'reference'), reference)
assert_equal(reply.get_arg(OPENID_NS, 'contact'), contact)
end
def failUnlessExpiresInMatches(msg, expected_expires_in)
expires_in_str = msg.get_arg(OPENID_NS, 'expires_in', NO_DEFAULT)
expires_in = expires_in_str.to_i
# Slop is necessary because the tests can sometimes get run
# right on a second boundary
slop = 1 # second
difference = expected_expires_in - expires_in
error_message = sprintf('"expires_in" value not within %s of expected: ' +
'expected=%s, actual=%s', slop, expected_expires_in,
expires_in)
assert((0 <= difference and difference <= slop), error_message)
end
def test_plaintext
@assoc = @signatory.create_association(false, 'HMAC-SHA1')
response = @request.answer(@assoc)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
assert_equal(rfg.call("assoc_handle"), @assoc.handle)
failUnlessExpiresInMatches(response.fields,
@signatory.secret_lifetime)
assert_equal(
rfg.call("mac_key"), Util.to_base64(@assoc.secret))
assert(!rfg.call("session_type"))
assert(!rfg.call("enc_mac_key"))
assert(!rfg.call("dh_server_public"))
end
def test_plaintext_v2
# The main difference between this and the v1 test is that
# session_type is always returned in v2.
args = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'associate',
'openid.assoc_type' => 'HMAC-SHA1',
'openid.session_type' => 'no-encryption',
}
@request = Server::AssociateRequest.from_message(
Message.from_post_args(args))
assert(!@request.message.is_openid1())
@assoc = @signatory.create_association(false, 'HMAC-SHA1')
response = @request.answer(@assoc)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
assert_equal(rfg.call("assoc_handle"), @assoc.handle)
failUnlessExpiresInMatches(
response.fields, @signatory.secret_lifetime)
assert_equal(
rfg.call("mac_key"), Util.to_base64(@assoc.secret))
assert_equal(rfg.call("session_type"), "no-encryption")
assert(!rfg.call("enc_mac_key"))
assert(!rfg.call("dh_server_public"))
end
def test_plaintext256
@assoc = @signatory.create_association(false, 'HMAC-SHA256')
response = @request.answer(@assoc)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
assert_equal(rfg.call("assoc_handle"), @assoc.handle)
failUnlessExpiresInMatches(
response.fields, @signatory.secret_lifetime)
assert_equal(
rfg.call("mac_key"), Util.to_base64(@assoc.secret))
assert(!rfg.call("session_type"))
assert(!rfg.call("enc_mac_key"))
assert(!rfg.call("dh_server_public"))
end
def test_unsupportedPrefer
allowed_assoc = 'COLD-PET-RAT'
allowed_sess = 'FROG-BONES'
message = 'This is a unit test'
# Set an OpenID 2 message so answerUnsupported doesn't raise
# ProtocolError.
@request.message = Message.new(OPENID2_NS)
response = @request.answer_unsupported(message,
allowed_assoc,
allowed_sess)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call('error_code'), 'unsupported-type')
assert_equal(rfg.call('assoc_type'), allowed_assoc)
assert_equal(rfg.call('error'), message)
assert_equal(rfg.call('session_type'), allowed_sess)
end
def test_unsupported
message = 'This is a unit test'
# Set an OpenID 2 message so answerUnsupported doesn't raise
# ProtocolError.
@request.message = Message.new(OPENID2_NS)
response = @request.answer_unsupported(message)
rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
assert_equal(rfg.call('error_code'), 'unsupported-type')
assert_equal(rfg.call('assoc_type'), nil)
assert_equal(rfg.call('error'), message)
assert_equal(rfg.call('session_type'), nil)
end
def test_openid1_unsupported_explode
# answer_unsupported on an associate request should explode if
# the request was an OpenID 1 request.
m = Message.new(OPENID1_NS)
assert_raise(Server::ProtocolError) {
@request.answer_unsupported(m)
}
end
end
class UnhandledError < Exception
end
class TestServer < Test::Unit::TestCase
include TestUtil
def setup
@store = Store::Memory.new()
@server = Server::Server.new(@store, "http://server.unittest/endpt")
# catchlogs_setup()
end
def test_failed_dispatch
request = Server::OpenIDRequest.new()
request.mode = "monkeymode"
request.message = Message.new(OPENID1_NS)
assert_raise(RuntimeError) {
@server.handle_request(request)
}
end
def test_decode_request
@server.decoder = BogusDecoder.new(@server)
assert(@server.decode_request({}) == "BOGUS")
end
def test_encode_response
@server.encoder = BogusEncoder.new
assert(@server.encode_response(nil) == "BOGUS")
end
def test_dispatch
@server.extend(InstanceDefExtension)
@server.instance_def(:openid_monkeymode) do |request|
raise UnhandledError
end
request = Server::OpenIDRequest.new()
request.mode = "monkeymode"
request.message = Message.new(OPENID1_NS)
assert_raise(UnhandledError) {
@server.handle_request(request)
}
end
def test_associate
request = Server::AssociateRequest.from_message(Message.from_post_args({}))
response = @server.openid_associate(request)
assert(response.fields.has_key?(OPENID_NS, "assoc_handle"),
sprintf("No assoc_handle here: %s", response.fields.inspect))
end
def test_associate2
# Associate when the server has no allowed association types
#
# Gives back an error with error_code and no fallback session or
# assoc types.
@server.negotiator.allowed_types = []
# Set an OpenID 2 message so answerUnsupported doesn't raise
# ProtocolError.
msg = Message.from_post_args({
'openid.ns' => OPENID2_NS,
'openid.session_type' => 'no-encryption',
})
request = Server::AssociateRequest.from_message(msg)
response = @server.openid_associate(request)
assert(response.fields.has_key?(OPENID_NS, "error"))
assert(response.fields.has_key?(OPENID_NS, "error_code"))
assert(!response.fields.has_key?(OPENID_NS, "assoc_handle"))
assert(!response.fields.has_key?(OPENID_NS, "assoc_type"))
assert(!response.fields.has_key?(OPENID_NS, "session_type"))
end
def test_associate3
# Request an assoc type that is not supported when there are
# supported types.
#
# Should give back an error message with a fallback type.
@server.negotiator.allowed_types = [['HMAC-SHA256', 'DH-SHA256']]
msg = Message.from_post_args({
'openid.ns' => OPENID2_NS,
'openid.session_type' => 'no-encryption',
})
request = Server::AssociateRequest.from_message(msg)
response = @server.openid_associate(request)
assert(response.fields.has_key?(OPENID_NS, "error"))
assert(response.fields.has_key?(OPENID_NS, "error_code"))
assert(!response.fields.has_key?(OPENID_NS, "assoc_handle"))
assert_equal(response.fields.get_arg(OPENID_NS, "assoc_type"),
'HMAC-SHA256')
assert_equal(response.fields.get_arg(OPENID_NS, "session_type"),
'DH-SHA256')
end
def test_associate4
# DH-SHA256 association session
@server.negotiator.allowed_types = [['HMAC-SHA256', 'DH-SHA256']]
query = {
'openid.dh_consumer_public' =>
'ALZgnx8N5Lgd7pCj8K86T/DDMFjJXSss1SKoLmxE72kJTzOtG6I2PaYrHX' +
'xku4jMQWSsGfLJxwCZ6280uYjUST/9NWmuAfcrBfmDHIBc3H8xh6RBnlXJ' +
'1WxJY3jHd5k1/ZReyRZOxZTKdF/dnIqwF8ZXUwI6peV0TyS/K1fOfF/s',
'openid.assoc_type' => 'HMAC-SHA256',
'openid.session_type' => 'DH-SHA256',
}
message = Message.from_post_args(query)
request = Server::AssociateRequest.from_message(message)
response = @server.openid_associate(request)
assert(response.fields.has_key?(OPENID_NS, "assoc_handle"))
end
def test_no_encryption_openid1
# Make sure no-encryption associate requests for OpenID 1 are
# logged.
assert_log_matches(/Continuing anyway./) {
m = Message.from_openid_args({
'session_type' => 'no-encryption',
})
Server::AssociateRequest.from_message(m)
}
end
def test_missingSessionTypeOpenID2
# Make sure session_type is required in OpenID 2
msg = Message.from_post_args({
'openid.ns' => OPENID2_NS,
})
assert_raises(Server::ProtocolError) {
Server::AssociateRequest.from_message(msg)
}
end
def test_checkAuth
request = Server::CheckAuthRequest.new('arrrrrf', '0x3999', [])
request.message = Message.new(OPENID2_NS)
response = nil
silence_logging {
response = @server.openid_check_authentication(request)
}
assert(response.fields.has_key?(OPENID_NS, "is_valid"))
end
end
class TestingRequest < Server::OpenIDRequest
attr_accessor :assoc_handle, :namespace
end
class TestSignatory < Test::Unit::TestCase
include TestUtil
def setup
@store = Store::Memory.new()
@signatory = Server::Signatory.new(@store)
@_dumb_key = @signatory.class._dumb_key
@_normal_key = @signatory.class._normal_key
# CatchLogs.setUp(self)
end
def test_get_association_nil
assert_raises(ArgumentError) {
@signatory.get_association(nil, false)
}
end
def test_sign
request = TestingRequest.new()
assoc_handle = '{assoc}{lookatme}'
@store.store_association(
@_normal_key,
Association.from_expires_in(60, assoc_handle,
'sekrit', 'HMAC-SHA1'))
request.assoc_handle = assoc_handle
request.namespace = OPENID1_NS
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'foo' => 'amsigned',
'bar' => 'notsigned',
'azu' => 'alsosigned',
})
sresponse = @signatory.sign(response)
assert_equal(
sresponse.fields.get_arg(OPENID_NS, 'assoc_handle'),
assoc_handle)
assert_equal(sresponse.fields.get_arg(OPENID_NS, 'signed'),
'assoc_handle,azu,bar,foo,signed')
assert(sresponse.fields.get_arg(OPENID_NS, 'sig'))
# assert(!@messages, @messages)
end
def test_signDumb
request = TestingRequest.new()
request.assoc_handle = nil
request.namespace = OPENID2_NS
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'foo' => 'amsigned',
'bar' => 'notsigned',
'azu' => 'alsosigned',
'ns' => OPENID2_NS,
})
sresponse = @signatory.sign(response)
assoc_handle = sresponse.fields.get_arg(OPENID_NS, 'assoc_handle')
assert(assoc_handle)
assoc = @signatory.get_association(assoc_handle, true)
assert(assoc)
assert_equal(sresponse.fields.get_arg(OPENID_NS, 'signed'),
'assoc_handle,azu,bar,foo,ns,signed')
assert(sresponse.fields.get_arg(OPENID_NS, 'sig'))
# assert(!@messages, @messages)
end
def test_signExpired
# Sign a response to a message with an expired handle (using
# invalidate_handle).
#
# From "Verifying with an Association":
#
# If an authentication request included an association handle
# for an association between the OP and the Relying party, and
# the OP no longer wishes to use that handle (because it has
# expired or the secret has been compromised, for instance),
# the OP will send a response that must be verified directly
# with the OP, as specified in Section 11.3.2. In that
# instance, the OP will include the field
# "openid.invalidate_handle" set to the association handle
# that the Relying Party included with the original request.
request = TestingRequest.new()
request.namespace = OPENID2_NS
assoc_handle = '{assoc}{lookatme}'
@store.store_association(
@_normal_key,
Association.from_expires_in(-10, assoc_handle,
'sekrit', 'HMAC-SHA1'))
assert(@store.get_association(@_normal_key, assoc_handle))
request.assoc_handle = assoc_handle
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'foo' => 'amsigned',
'bar' => 'notsigned',
'azu' => 'alsosigned',
})
sresponse = nil
silence_logging {
sresponse = @signatory.sign(response)
}
new_assoc_handle = sresponse.fields.get_arg(OPENID_NS, 'assoc_handle')
assert(new_assoc_handle)
assert(new_assoc_handle != assoc_handle)
assert_equal(
sresponse.fields.get_arg(OPENID_NS, 'invalidate_handle'),
assoc_handle)
assert_equal(sresponse.fields.get_arg(OPENID_NS, 'signed'),
'assoc_handle,azu,bar,foo,invalidate_handle,signed')
assert(sresponse.fields.get_arg(OPENID_NS, 'sig'))
# make sure the expired association is gone
assert(!@store.get_association(@_normal_key, assoc_handle),
"expired association is still retrievable.")
# make sure the new key is a dumb mode association
assert(@store.get_association(@_dumb_key, new_assoc_handle))
assert(!@store.get_association(@_normal_key, new_assoc_handle))
# assert(@messages)
end
def test_signInvalidHandle
request = TestingRequest.new()
request.namespace = OPENID2_NS
assoc_handle = '{bogus-assoc}{notvalid}'
request.assoc_handle = assoc_handle
response = Server::OpenIDResponse.new(request)
response.fields = Message.from_openid_args({
'foo' => 'amsigned',
'bar' => 'notsigned',
'azu' => 'alsosigned',
})
sresponse = @signatory.sign(response)
new_assoc_handle = sresponse.fields.get_arg(OPENID_NS, 'assoc_handle')
assert(new_assoc_handle)
assert(new_assoc_handle != assoc_handle)
assert_equal(
sresponse.fields.get_arg(OPENID_NS, 'invalidate_handle'),
assoc_handle)
assert_equal(
sresponse.fields.get_arg(OPENID_NS, 'signed'),
'assoc_handle,azu,bar,foo,invalidate_handle,signed')
assert(sresponse.fields.get_arg(OPENID_NS, 'sig'))
# make sure the new key is a dumb mode association
assert(@store.get_association(@_dumb_key, new_assoc_handle))
assert(!@store.get_association(@_normal_key, new_assoc_handle))
# @failIf(@messages, @messages)
end
def test_verify
assoc_handle = '{vroom}{zoom}'
assoc = Association.from_expires_in(
60, assoc_handle, 'sekrit', 'HMAC-SHA1')
@store.store_association(@_dumb_key, assoc)
signed = Message.from_post_args({
'openid.foo' => 'bar',
'openid.apple' => 'orange',
'openid.assoc_handle' => assoc_handle,
'openid.signed' => 'apple,assoc_handle,foo,signed',
'openid.sig' => 'uXoT1qm62/BB09Xbj98TQ8mlBco=',
})
verified = @signatory.verify(assoc_handle, signed)
assert(verified)
# assert(!@messages, @messages)
end
def test_verifyBadSig
assoc_handle = '{vroom}{zoom}'
assoc = Association.from_expires_in(
60, assoc_handle, 'sekrit', 'HMAC-SHA1')
@store.store_association(@_dumb_key, assoc)
signed = Message.from_post_args({
'openid.foo' => 'bar',
'openid.apple' => 'orange',
'openid.assoc_handle' => assoc_handle,
'openid.signed' => 'apple,assoc_handle,foo,signed',
'openid.sig' => 'uXoT1qm62/BB09Xbj98TQ8mlBco=BOGUS'
})
verified = @signatory.verify(assoc_handle, signed)
# @failIf(@messages, @messages)
assert(!verified)
end
def test_verifyBadHandle
assoc_handle = '{vroom}{zoom}'
signed = Message.from_post_args({
'foo' => 'bar',
'apple' => 'orange',
'openid.sig' => "Ylu0KcIR7PvNegB/K41KpnRgJl0=",
})
verified = nil
silence_logging {
verified = @signatory.verify(assoc_handle, signed)
}
assert !verified
end
def test_verifyAssocMismatch
# Attempt to validate sign-all message with a signed-list assoc.
assoc_handle = '{vroom}{zoom}'
assoc = Association.from_expires_in(
60, assoc_handle, 'sekrit', 'HMAC-SHA1')
@store.store_association(@_dumb_key, assoc)
signed = Message.from_post_args({
'foo' => 'bar',
'apple' => 'orange',
'openid.sig' => "d71xlHtqnq98DonoSgoK/nD+QRM=",
})
verified = nil
silence_logging {
verified = @signatory.verify(assoc_handle, signed)
}
assert !verified
end
def test_getAssoc
assoc_handle = makeAssoc(true)
assoc = @signatory.get_association(assoc_handle, true)
assert assoc
assert_equal assoc.handle, assoc_handle
end
def test_getAssocExpired
assoc_handle = makeAssoc(true, -10)
assoc = nil
silence_logging {
assoc = @signatory.get_association(assoc_handle, true)
}
assert !assoc
end
def test_getAssocInvalid
ah = 'no-such-handle'
silence_logging {
assert_equal(
@signatory.get_association(ah, false), nil)
}
# assert(!@messages, @messages)
end
def test_getAssocDumbVsNormal
# getAssociation(dumb=False) cannot get a dumb assoc
assoc_handle = makeAssoc(true)
silence_logging {
assert_equal(
@signatory.get_association(assoc_handle, false), nil)
}
# @failIf(@messages, @messages)
end
def test_getAssocNormalVsDumb
# getAssociation(dumb=True) cannot get a shared assoc
#
# From "Verifying Directly with the OpenID Provider"::
#
# An OP MUST NOT verify signatures for associations that have shared
# MAC keys.
assoc_handle = makeAssoc(false)
silence_logging {
assert_equal(
@signatory.get_association(assoc_handle, true), nil)
}
# @failIf(@messages, @messages)
end
def test_createAssociation
assoc = @signatory.create_association(false)
silence_logging {
assert(@signatory.get_association(assoc.handle, false))
}
# @failIf(@messages, @messages)
end
def makeAssoc(dumb, lifetime=60)
assoc_handle = '{bling}'
assoc = Association.from_expires_in(lifetime, assoc_handle,
'sekrit', 'HMAC-SHA1')
silence_logging {
@store.store_association(((dumb and @_dumb_key) or @_normal_key), assoc)
}
return assoc_handle
end
def test_invalidate
assoc_handle = '-squash-'
assoc = Association.from_expires_in(60, assoc_handle,
'sekrit', 'HMAC-SHA1')
silence_logging {
@store.store_association(@_dumb_key, assoc)
assoc = @signatory.get_association(assoc_handle, true)
assert(assoc)
assoc = @signatory.get_association(assoc_handle, true)
assert(assoc)
@signatory.invalidate(assoc_handle, true)
assoc = @signatory.get_association(assoc_handle, true)
assert(!assoc)
}
# @failIf(@messages, @messages)
end
end
class RunthroughTestCase < Test::Unit::TestCase
def setup
@store = Store::Memory.new
@server = Server::Server.new(@store, "http://example.com/openid/server")
end
def test_openid1_assoc_checkid
assoc_args = {'openid.mode' => 'associate',
'openid.assoc_type' => 'HMAC-SHA1'}
areq = @server.decode_request(assoc_args)
aresp = @server.handle_request(areq)
amess = aresp.fields
assert(amess.is_openid1)
ahandle = amess.get_arg(OPENID_NS, 'assoc_handle')
assert(ahandle)
assoc = @store.get_association('http://localhost/|normal', ahandle)
assert(assoc.is_a?(Association))
checkid_args = {'openid.mode' => 'checkid_setup',
'openid.return_to' => 'http://example.com/openid/consumer',
'openid.assoc_handle' => ahandle,
'openid.identity' => 'http://foo.com/'}
cireq = @server.decode_request(checkid_args)
ciresp = cireq.answer(true)
signed_resp = @server.signatory.sign(ciresp)
assert_equal(assoc.get_message_signature(signed_resp.fields),
signed_resp.fields.get_arg(OPENID_NS, 'sig'))
assert(assoc.check_message_signature(signed_resp.fields))
end
end
end
|
apache-2.0
|
tomighty/tomighty-windows
|
Tomighty.Core.Test/FakeEventHub.cs
|
1755
|
//
// Tomighty - http://www.tomighty.org
//
// This software is licensed under the Apache License Version 2.0:
// http://www.apache.org/licenses/LICENSE-2.0.txt
//
using System;
using System.Collections.Generic;
using System.Linq;
namespace Tomighty.Test
{
public class FakeEventHub : IEventHub
{
private readonly List<Subscriber> subscribers = new List<Subscriber>();
private readonly List<object> publishedEvents = new List<object>();
public IEnumerable<T> PublishedEvents<T>()
{
return publishedEvents.Where(e => e.GetType() == typeof(T)).Select(e => (T) e);
}
public T LastEvent<T>()
{
return PublishedEvents<T>().LastOrDefault();
}
public void Publish(object @event)
{
publishedEvents.Add(@event);
foreach (var subscriber in subscribers)
{
subscriber.Handle(@event);
}
}
public void Subscribe<T>(Action<T> eventHandler)
{
Action<object> proxy = @event => eventHandler((T) @event);
subscribers.Add(new Subscriber(typeof(T), proxy));
}
private class Subscriber
{
private readonly Type eventType;
private readonly Action<object> eventHandler;
public Subscriber(Type eventType, Action<object> eventHandler)
{
this.eventType = eventType;
this.eventHandler = eventHandler;
}
public void Handle(object @event)
{
if (eventType == @event.GetType())
{
eventHandler(@event);
}
}
}
}
}
|
apache-2.0
|
crnk-project/crnk-framework
|
crnk-core/src/main/java/io/crnk/core/queryspec/pagingspec/OffsetLimitPagingSpec.java
|
2509
|
package io.crnk.core.queryspec.pagingspec;
import io.crnk.core.engine.internal.utils.CompareUtils;
import io.crnk.core.exception.BadRequestException;
public class OffsetLimitPagingSpec implements PagingSpec {
private Long limit = null;
private Long offset = 0L;
public OffsetLimitPagingSpec() {
}
public OffsetLimitPagingSpec(final Long offset, final Long limit) {
this.offset = offset;
this.limit = limit;
}
public Long getLimit() {
return limit;
}
public long getOffset() {
return offset;
}
public OffsetLimitPagingSpec setLimit(final Long limit) {
this.limit = limit;
return this;
}
public OffsetLimitPagingSpec setOffset(final long offset) {
this.offset = offset;
return this;
}
@Override
public OffsetLimitPagingSpec clone() {
return new OffsetLimitPagingSpec(offset, limit);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((limit == null) ? 0 : limit.hashCode());
result = prime * result + Long.valueOf(offset).hashCode();
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
OffsetLimitPagingSpec other = (OffsetLimitPagingSpec) obj;
return CompareUtils.isEquals(limit, other.limit)
&& CompareUtils.isEquals(offset, other.offset);
}
@Override
public String toString() {
return "OffsetLimitPagingSpec[" +
(offset != null ? "offset=" + offset : "") +
(limit != null ? ", limit=" + limit : "") +
']';
}
public <T extends PagingSpec> T convert(Class<T> pagingSpecType) {
if(pagingSpecType.isInstance(this)){
return (T)this;
}
if (pagingSpecType.equals(NumberSizePagingSpec.class)) {
if (offset == 0 && limit == null) {
return (T) new NumberSizePagingSpec(1, null);
} else if (offset == 0) {
return (T) new NumberSizePagingSpec(1, limit.intValue());
} else if (offset != 0 && limit == null) {
throw new UnsupportedOperationException("cannot use page offset without page limit");
} else {
int number = (int) (offset / limit);
if (number * limit != offset) {
throw new BadRequestException(
String.format("offset=%s must be multiple of limit=%s to support page number/size conversion",
offset, limit));
}
return (T) new NumberSizePagingSpec(1 + number, limit.intValue());
}
}
throw new UnsupportedOperationException("cannot converted to " + pagingSpecType);
}
}
|
apache-2.0
|
googleapis/dotnet-spanner-entity-framework
|
Google.Cloud.EntityFrameworkCore.Spanner/Extensions/SpannerIDbContextTransactionExtensions.cs
|
3087
|
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using Google.Api.Gax;
using Google.Cloud.EntityFrameworkCore.Spanner.Storage.Internal;
using JetBrains.Annotations;
using Microsoft.EntityFrameworkCore.Storage;
using System;
namespace Google.Cloud.EntityFrameworkCore.Spanner.Extensions
{
/// <summary>
/// Extensions for Cloud Spanner transactions.
/// </summary>
public static class SpannerIDbContextTransactionExtensions
{
/// <summary>
/// Disables internal retries for Aborted errors for the transaction. Internal retries are enabled by default.
/// This method may only be called for read/write Spanner transactions.
/// </summary>
/// <param name="dbContextTransaction">The transaction to disable internal retries for.</param>
/// <exception cref="ArgumentException">If the transaction is not a read/write Spanner transaction</exception>
public static void DisableInternalRetries([NotNull] this IDbContextTransaction dbContextTransaction)
{
GaxPreconditions.CheckArgument(dbContextTransaction.GetDbTransaction() is SpannerRetriableTransaction, nameof(dbContextTransaction), "Must be a read/write Spanner transaction");
((SpannerRetriableTransaction) dbContextTransaction.GetDbTransaction()).EnableInternalRetries = false;
}
/// <summary>
/// The commit timestamp of the transaction. This property is only valid for read/write Spanner transactions that have committed.
/// </summary>
/// <param name="dbContextTransaction"></param>
/// <returns>The commit timestamp of the transaction</returns>
/// <exception cref="ArgumentException">If the transaction is not a read/write Spanner transaction</exception>
/// <exception cref="InvalidOperationException">If the Spanner transaction has not committed</exception>
public static DateTime GetCommitTimestamp([NotNull] this IDbContextTransaction dbContextTransaction)
{
GaxPreconditions.CheckArgument(dbContextTransaction.GetDbTransaction() is SpannerRetriableTransaction, nameof(dbContextTransaction), "Must be a read/write Spanner transaction");
return ((SpannerRetriableTransaction) dbContextTransaction.GetDbTransaction()).CommitTimestamp;
}
// TODO: Add method for GetReadTimestamp for read-only transactions.
// That requires an addition to the client library to actually be able
// to get the read timestamp of a read-only transaction.
}
}
|
apache-2.0
|
intel-analytics/BigDL
|
scala/dllib/src/main/scala/com/intel/analytics/bigdl/dllib/nn/internal/Recurrent.scala
|
2412
|
/*
* Copyright 2016 The BigDL Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intel.analytics.bigdl.dllib.nn.internal
import com.intel.analytics.bigdl.dllib.nn.{Cell, Reverse, Select, Sequential => TSequential}
import com.intel.analytics.bigdl.dllib.nn.abstractnn.AbstractModule
import com.intel.analytics.bigdl.dllib.tensor.Tensor
import com.intel.analytics.bigdl.dllib.tensor.TensorNumericMath.TensorNumeric
import com.intel.analytics.bigdl.dllib.utils.Shape
import scala.reflect.ClassTag
/**
* This is the abstract base class for recurrent layers.
* Do not create a new instance of it or use it in a model.
* Please use its child classes, 'SimpleRNN', 'LSTM' and 'GRU' instead.
*/
abstract class Recurrent[T: ClassTag](
val outputDim: Int,
val returnSequences: Boolean = false,
val goBackwards: Boolean = false,
val inputShape: Shape = null)(implicit ev: TensorNumeric[T])
extends KerasLayer[Tensor[T], Tensor[T], T](KerasLayer.addBatch(inputShape)) {
override def computeOutputShape(inputShape: Shape): Shape = {
val input = inputShape.toSingle().toArray
require(input.length == 3,
s"Recurrent layers require 3D input, but got input dim ${input.length}")
if (returnSequences) Shape(input(0), input(1), outputDim)
else Shape(input(0), outputDim)
}
def buildCell(input: Array[Int]): Cell[T] = {
throw new RuntimeException("Recurrent cell haven't been implemented yet.")
}
override def doBuild(inputShape: Shape): AbstractModule[Tensor[T], Tensor[T], T] = {
val input = inputShape.toSingle().toArray
val model = TSequential[T]()
if (goBackwards) model.add(Reverse(2))
val rec = com.intel.analytics.bigdl.dllib.nn.Recurrent[T]()
rec.add(buildCell(input))
model.add(rec)
if (!returnSequences) model.add(Select(2, -1))
model.asInstanceOf[AbstractModule[Tensor[T], Tensor[T], T]]
}
}
|
apache-2.0
|
oehme/analysing-gradle-performance
|
my-app/src/main/java/org/gradle/test/performance/mediummonolithicjavaproject/p122/Production2447.java
|
1891
|
package org.gradle.test.performance.mediummonolithicjavaproject.p122;
public class Production2447 {
private String property0;
public String getProperty0() {
return property0;
}
public void setProperty0(String value) {
property0 = value;
}
private String property1;
public String getProperty1() {
return property1;
}
public void setProperty1(String value) {
property1 = value;
}
private String property2;
public String getProperty2() {
return property2;
}
public void setProperty2(String value) {
property2 = value;
}
private String property3;
public String getProperty3() {
return property3;
}
public void setProperty3(String value) {
property3 = value;
}
private String property4;
public String getProperty4() {
return property4;
}
public void setProperty4(String value) {
property4 = value;
}
private String property5;
public String getProperty5() {
return property5;
}
public void setProperty5(String value) {
property5 = value;
}
private String property6;
public String getProperty6() {
return property6;
}
public void setProperty6(String value) {
property6 = value;
}
private String property7;
public String getProperty7() {
return property7;
}
public void setProperty7(String value) {
property7 = value;
}
private String property8;
public String getProperty8() {
return property8;
}
public void setProperty8(String value) {
property8 = value;
}
private String property9;
public String getProperty9() {
return property9;
}
public void setProperty9(String value) {
property9 = value;
}
}
|
apache-2.0
|
carewebframework/carewebframework-rpms
|
org.carewebframework.rpms.plugin-parent/org.carewebframework.rpms.plugin.anticoag/src/main/java/org/carewebframework/rpms/plugin/anticoag/DeleteController.java
|
3735
|
/*
* #%L
* carewebframework
* %%
* Copyright (C) 2008 - 2017 Regenstrief Institute, Inc.
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This Source Code Form is also subject to the terms of the Health-Related
* Additional Disclaimer of Warranty and Limitation of Liability available at
*
* http://www.carewebframework.org/licensing/disclaimer.
*
* #L%
*/
package org.carewebframework.rpms.plugin.anticoag;
import java.util.HashMap;
import java.util.Map;
import org.carewebframework.ui.FrameworkController;
import org.carewebframework.ui.zk.PopupDialog;
import org.carewebframework.ui.zk.PromptDialog;
import org.carewebframework.ui.zk.ZKUtil;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.util.Clients;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Radiogroup;
import org.zkoss.zul.Textbox;
/**
* Controller for anticoagulation management.
*/
public class DeleteController extends FrameworkController {
private static final long serialVersionUID = 1L;
private static final String DIALOG = ZKUtil.getResourcePath(DeleteController.class) + "delete.zul";
private static final String ATTR_OK = "ok";
private Service service;
private Textbox txtOther;
private Radio radOther;
private Radiogroup rgReason;
private AntiCoagRecord record;
public static boolean show(AntiCoagRecord record) {
Map<Object, Object> args = new HashMap<Object, Object>();
args.put("record", record);
return PopupDialog.popup(DIALOG, args, false, false, true).hasAttribute(ATTR_OK);
}
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
record = (AntiCoagRecord) arg.get("record");
}
public void setService(Service service) {
this.service = service;
}
public void onCheck$rgReason() {
clearMessages();
}
public void onCheck$radOther() {
txtOther.setFocus(true);
clearMessages();
}
public void onFocus$txtOther() {
radOther.setSelected(true);
clearMessages();
}
private void clearMessages() {
Clients.clearWrongValue(txtOther);
Clients.clearWrongValue(rgReason);
}
public void onClick$btnOK() {
clearMessages();
Radio radio = rgReason.getSelectedItem();
String reasonCode = radio == null ? null : (String) radio.getValue();
if (reasonCode == null) {
Clients.wrongValue(rgReason, "You must select a reason for the deletion.");
return;
}
String reasonText = "3".equals(reasonCode) ? txtOther.getText().trim() : null;
if (reasonText != null && reasonText.isEmpty()) {
Clients.wrongValue(txtOther, "Please enter text describing the reason for the deletion.");
return;
}
try {
service.delete(record, reasonCode, reasonText);
} catch (Exception e) {
PromptDialog.showError(e.getMessage());
return;
}
root.setAttribute("ok", true);
root.detach();
}
}
|
apache-2.0
|
ronq/geomesa
|
geomesa-accumulo/geomesa-accumulo-raster/src/main/scala/org/locationtech/geomesa/raster/data/GeoMesaCoverageQueryParams.scala
|
2609
|
/***********************************************************************
* Copyright (c) 2013-2017 Commonwealth Computer Research, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Apache License, Version 2.0
* which accompanies this distribution and is available at
* http://www.opensource.org/licenses/apache2.0.php.
***********************************************************************/
package org.locationtech.geomesa.raster.data
import org.geotools.coverage.grid.GridGeometry2D
import org.geotools.coverage.grid.io.AbstractGridFormat
import org.geotools.parameter.Parameter
import org.locationtech.geomesa.raster.util.RasterUtils
import org.locationtech.geomesa.utils.geohash.{BoundingBox, Bounds}
import org.opengis.parameter.GeneralParameterValue
/**
* Takes the Array[GeneralParameterValue] from the read() function of GeoMesaCoverageReader and pulls
* out the gridGeometry, envelope, height and width, resolution, and bounding box from the query
* parameters. These are then used to query Accumulo and retrieve out the correct raster information.
* @param parameters the Array of GeneralParameterValues from the GeoMesaCoverageReader read() function.
*/
class GeoMesaCoverageQueryParams(parameters: Array[GeneralParameterValue]) {
val paramsMap = parameters.map { gpv => (gpv.getDescriptor.getName.getCode, gpv) }.toMap
val gridGeometry = paramsMap(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName.toString)
.asInstanceOf[Parameter[GridGeometry2D]].getValue
val envelope = gridGeometry.getEnvelope
val dim = gridGeometry.getGridRange2D.getBounds
val rasterParams = RasterUtils.sharedRasterParams(gridGeometry, envelope)
val width = rasterParams.width
val height = rasterParams.height
val resX = rasterParams.resX
val resY = rasterParams.resY
val suggestedQueryResolution = rasterParams.suggestedQueryResolution
val min = Array(correctedMinLongitude, correctedMinLatitude)
val max = Array(correctedMaxLongitude, correctedMaxLatitude)
val bbox = BoundingBox(Bounds(min(0), max(0)), Bounds(min(1), max(1)))
def toRasterQuery: RasterQuery = RasterQuery(bbox, suggestedQueryResolution, None, None)
def correctedMaxLongitude: Double = Math.max(Math.min(envelope.getMaximum(0), 180), -180.0)
def correctedMinLongitude: Double = Math.min(Math.max(envelope.getMinimum(0), -180), 180.0)
def correctedMaxLatitude: Double = Math.max(Math.min(envelope.getMaximum(1), 90), -90.0)
def correctedMinLatitude: Double = Math.min(Math.max(envelope.getMinimum(1), -90), 90.0)
}
|
apache-2.0
|
taktos/ea2ddl
|
ea2ddl-dao/src/main/java/jp/sourceforge/ea2ddl/dao/exentity/TTestplans.java
|
417
|
package jp.sourceforge.ea2ddl.dao.exentity;
/**
* The entity of t_testplans.
* <p>
* You can implement your original methods here.
* This class remains when re-generating.
* </p>
* @author DBFlute(AutoGenerator)
*/
public class TTestplans extends jp.sourceforge.ea2ddl.dao.bsentity.BsTTestplans {
/** Serial version UID. (Default) */
private static final long serialVersionUID = 1L;
}
|
apache-2.0
|
asim/mq
|
go/client/client.go
|
1144
|
package client
// Client is the interface provided by this package
type Client interface {
Close() error
Publish(topic string, payload []byte) error
Subscribe(topic string) (<-chan []byte, error)
Unsubscribe(<-chan []byte) error
}
// Resolver resolves a name to a list of servers
type Resolver interface {
Resolve(name string) ([]string, error)
}
// Selector provides a server list to publish/subscribe to
type Selector interface {
Get(topic string) ([]string, error)
Set(servers ...string) error
}
var (
// The default client
Default = New()
// The default server list
Servers = []string{"http://127.0.0.1:8081"}
// The default number of retries
Retries = 1
)
// Publish via the default Client
func Publish(topic string, payload []byte) error {
return Default.Publish(topic, payload)
}
// Subscribe via the default Client
func Subscribe(topic string) (<-chan []byte, error) {
return Default.Subscribe(topic)
}
// Unsubscribe via the default Client
func Unsubscribe(ch <-chan []byte) error {
return Default.Unsubscribe(ch)
}
// New returns a new Client
func New(opts ...Option) Client {
return newHTTPClient(opts...)
}
|
apache-2.0
|
werval/werval
|
io.werval/io.werval.test/src/main/java/io/werval/test/WervalHttpRule.java
|
2973
|
/*
* Copyright (c) 2013-2014 the original author or authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.werval.test;
import io.werval.runtime.routes.RoutesProvider;
import io.werval.spi.ApplicationSPI;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
/**
* Werval HTTP JUnit Rule.
* <p>
* Activate/Passivate Werval Application and HTTP Server in test mode around JUnit tests.
* <p>
* Can be used to activate/passivate around each method test as a {@literal @}{@link Rule} or around each test class
* as a {@literal @}{@link ClassRule}.
* <p>
* By default, configuration is loaded from the <code>application.conf</code> file and routes are loaded from the
* <code>routes.conf</code> file.
* <p>
* Use the various constructors to to provide your own test configuration and routes.
*
* @composed 1 - 1 WervalHttpTest
*/
public class WervalHttpRule
implements WervalHttpTestSupport, TestRule
{
private final WervalHttpTest werval;
public WervalHttpRule()
{
this( null, null );
}
public WervalHttpRule( String configurationResourceName )
{
this( configurationResourceName, null );
}
public WervalHttpRule( RoutesProvider routesProvider )
{
this( null, routesProvider );
}
public WervalHttpRule( String configurationResourceName, RoutesProvider routesProvider )
{
werval = new WervalHttpTest( configurationResourceName, routesProvider );
}
@Override
public final ApplicationSPI application()
{
return werval.application();
}
@Override
public final String httpHost()
{
return werval.httpHost();
}
@Override
public final int httpPort()
{
return werval.httpPort();
}
@Override
public final String baseHttpUrl()
{
return werval.baseHttpUrl();
}
@Override
public Statement apply( final Statement statement, Description description )
{
return new Statement()
{
@Override
public void evaluate()
throws Throwable
{
werval.beforeEachTestMethod();
try
{
statement.evaluate();
}
finally
{
werval.afterEachTestMethod();
}
}
};
}
}
|
apache-2.0
|
InterlakeHighSchoolMachineLearningClub/Colorizer
|
Colorizer/Colorizer/DSL/FilterSyntax/FilterRegistery.cs
|
3810
|
using Colorizer.Imaging;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Colorizer.DSL.FilterSyntax
{
public static class FilterRegistery
{
public static MetaImageFilter MetaFilter = new MetaImageFilter();
public static LockBitmap Bitmap { get; private set; }
public static PictureBox PictureBox { get; private set; }
private static Dictionary<string, Type> typeDictionary;
private static Dictionary<string, Action<string[]>> commandDictionary;
static FilterRegistery()
{
FilterRegistery.typeDictionary = new Dictionary<string, Type>();
FilterRegistery.commandDictionary = new Dictionary<string, Action<string[]>>();
FilterRegistery.commandDictionary.Add("clear", (x) => FilterRegistery.MetaFilter.Clear());
FilterRegistery.commandDictionary.Add("+filter", (x) =>
{
var type = FilterRegistery.typeDictionary[x[1]];
var ctor = type.GetConstructor(new Type[] { });
var instance = ctor.Invoke(new Type[] { });
foreach (var item in x.Skip(2))
{
FilterRegistery.SetNecessaryPropertiesFromUnaryString(instance, type, item);
}
FilterRegistery.MetaFilter.Add(instance as IImageFilter);
});
FilterRegistery.commandDictionary.Add("-filter", (x) =>
FilterRegistery.MetaFilter.Remove(int.Parse(x[1])));
FilterRegistery.commandDictionary.Add("show", (x) =>
FilterRegistery.PictureBox.Image = FilterRegistery.MetaFilter.Filter(FilterRegistery.Bitmap));
FilterRegistery.commandDictionary.Add("show-filters", (x) =>
{
Console.WriteLine();
foreach (var item in FilterRegistery.MetaFilter)
{
Console.Write(item.ToString().Split('.').Last() + " ");
}
Console.WriteLine();
});
}
public static void RegisterBitmap(LockBitmap bit)
{
FilterRegistery.Bitmap = bit;
}
public static void RegisterPictureBox(PictureBox pc)
{
FilterRegistery.PictureBox = pc;
}
public static void Register<T>(T a, string s) where T : IImageFilter, new()
{
FilterRegistery.typeDictionary.Add(s, typeof(T));
}
public static bool AppendCommand(string command)
{
var cleanCommad = command.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
try
{
FilterRegistery.commandDictionary[cleanCommad[0]](cleanCommad);
}
catch
{
return false;
}
return true;
}
private static void SetNecessaryPropertiesFromUnaryString(object obj, Type tm, string s)
{
var split = s.Split('|');
PropertyInfo info = tm.GetProperty(split[0]);
if (split[1] == "true" || split[1] == "false")
{
info.SetValue(obj, bool.Parse(split[1]));
return;
}
var len = split[1].Length;
switch (split[1].Last())
{
case 'I':
info.SetValue(obj, int.Parse(split[1].Remove(len - 1, 1)));
return;
case 'D':
info.SetValue(obj, double.Parse(split[1].Remove(len - 1, 1)));
return;
}
}
}
}
|
apache-2.0
|
czcorpus/klogproc
|
load/tail/watchdog.go
|
5588
|
// Copyright 2019 Tomas Machalek <tomas.machalek@gmail.com>
// Copyright 2019 Institute of the Czech National Corpus,
// Faculty of Arts, Charles University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package tail
import (
"log"
"os"
"os/signal"
"sync"
"syscall"
"time"
"github.com/czcorpus/klogproc/conversion"
"github.com/czcorpus/klogproc/save"
)
const (
defaultTickerIntervalSecs = 60
)
// FileConf represents a configuration for a single
// log file to be watched
type FileConf struct {
Path string `json:"path"`
AppType string `json:"appType"`
// Version represents a major and minor version signature as used in semantic versioning
// (e.g. 0.15, 1.2)
Version string `json:"version"`
TZShift int `json:"tzShift"`
}
func (fc *FileConf) GetPath() string {
return fc.Path
}
func (fc *FileConf) GetAppType() string {
return fc.AppType
}
// Conf wraps all the configuration for the 'tail' function
type Conf struct {
IntervalSecs int `json:"intervalSecs"`
WorklogPath string `json:"worklogPath"`
Files []FileConf `json:"files"`
NumErrorsAlarm int `json:"numErrorsAlarm"`
ErrCountTimeRangeSecs int `json:"errCountTimeRangeSecs"`
}
// FileTailProcessor specifies an object which is able to utilize all
// the "events" watchdog provides when processing a file tail for
// a concrete appType
type FileTailProcessor interface {
AppType() string
FilePath() string
CheckIntervalSecs() int
OnCheckStart() chan interface{}
OnEntry(item string, logPosition conversion.LogRange)
OnCheckStop()
OnQuit()
}
// ClientAnalyzer represents an object which is able to recognize
// bots etc. based on IP and/or user agent.
type ClientAnalyzer interface {
AgentIsMonitor(rec conversion.InputRecord) bool
AgentIsBot(rec conversion.InputRecord) bool
HasBlacklistedIP(rec conversion.InputRecord) bool
}
func initReaders(processors []FileTailProcessor, worklog *Worklog) ([]*FileTailReader, error) {
readers := make([]*FileTailReader, len(processors))
for i, processor := range processors {
wlItem := worklog.GetData(processor.FilePath())
log.Printf("INFO: Found log file %s", processor.FilePath())
if wlItem.Inode > -1 {
log.Printf("INFO: Found worklog for %s: %v", processor.FilePath(), wlItem)
} else {
log.Printf("WARNING: no worklog for %s - creating a new one...", processor.FilePath())
inode, err := worklog.ResetFile(processor.FilePath())
if err != nil {
return readers, err
}
log.Printf("INFO: ... added a worklog record for %s, inode: %d", processor.FilePath(), inode)
}
rdr, err := NewReader(
processor,
worklog.GetData(processor.FilePath()),
)
if err != nil {
return readers, err
}
readers[i] = rdr
}
return readers, nil
}
// Run starts the process of (multiple) log watching
func Run(conf *Conf, processors []FileTailProcessor, clientAnalyzer ClientAnalyzer, finishEvent chan<- bool) {
tickerInterval := time.Duration(conf.IntervalSecs)
if tickerInterval == 0 {
log.Printf("WARNING: intervalSecs for tail mode not set, using default %ds", defaultTickerIntervalSecs)
tickerInterval = time.Duration(defaultTickerIntervalSecs)
} else {
log.Printf("INFO: configured to check for file changes every %d second(s)", tickerInterval)
}
ticker := time.NewTicker(tickerInterval * time.Second)
quitChan := make(chan bool, 10)
syscallChan := make(chan os.Signal, 10)
signal.Notify(syscallChan, os.Interrupt)
signal.Notify(syscallChan, syscall.SIGTERM)
worklog := NewWorklog(conf.WorklogPath)
var readers []*FileTailReader
err := worklog.Init()
if err != nil {
log.Print("ERROR: ", err)
quitChan <- true
} else {
readers, err = initReaders(processors, worklog)
if err != nil {
log.Print("ERROR: ", err)
quitChan <- true
}
}
for {
select {
case <-ticker.C:
var wg sync.WaitGroup
wg.Add(len(readers))
for _, reader := range readers {
go func(rdr *FileTailReader) {
actionChan := rdr.Processor().OnCheckStart()
go func() {
for action := range actionChan {
switch action := action.(type) {
case save.ConfirmMsg:
if action.Error != nil {
log.Printf("ERROR: failed to write data to one of target databases: %s ...", action.Error)
}
worklog.UpdateFileInfo(action.FilePath, action.Position)
case save.IgnoredItemMsg:
worklog.UpdateFileInfo(action.FilePath, action.Position)
}
}
wg.Done()
}()
prevPos := worklog.GetData(rdr.processor.FilePath())
rdr.ApplyNewContent(rdr.Processor(), prevPos)
rdr.Processor().OnCheckStop()
}(reader)
}
wg.Wait()
case quit := <-quitChan:
if quit {
ticker.Stop()
for _, processor := range processors {
processor.OnQuit()
}
worklog.Close()
finishEvent <- true
}
case <-syscallChan:
log.Print("WARNING: Caught signal, exiting...")
ticker.Stop()
for _, reader := range readers {
reader.Processor().OnQuit()
}
worklog.Close()
finishEvent <- true
}
}
}
|
apache-2.0
|
Bigotry/OneBase
|
app/common/service/pay/driver/yeepay/sendCancelOrd.php
|
1829
|
<?php
header("Content-type: text/html; charset=utf-8");
include 'yeepayCommon.php';
require_once 'HttpClient.class.php';
$data = array();
$data['p0_Cmd'] = "CancelOrd";
$data['p1_MerId'] = $p1_MerId;
$data['pb_TrxId'] = $_REQUEST['pb_TrxId'];
$data['pv_Ver'] = $_REQUEST['pv_Ver'];
$hmacstring = HmacMd5(implode($data),$merchantKey);
$data['hmac'] = $hmacstring ;
//发送请求
$respdata = HttpClient::quickPost($reqURL_onLine, $data);
//var_dump($respdata );
//响应参数
$arr = getresp($respdata);
//echo "return:".$arr['hmac'];
//本地签名
$hmacLocal = HmacLocal($arr);
$safeLocal= gethamc_safe($arr);
//echo "local:".$hmacLocal;
//验签
if($arr['hmac'] != $hmacLocal || $arr['hmac_safe'] != $safeLocal)
{
echo "签名验证失败";
return;
}
?>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GBK">
<title>订单取消</title>
</head>
<body>
<br /> <br />
<table width="70%" border="0" align="center" cellpadding="5" cellspacing="0" style="border:solid 1px #107929">
<tr>
<th align="center" height="30" colspan="5" bgcolor="#6BBE18">
订单取消
</th>
</tr>
<tr>
<td width="25%" align="left"> 业务类型</td>
<td width="5%" align="center"> : </td>
<td width="35%" align="left"> <?php echo $arr['r0_Cmd'];?> </td>
<td width="5%" align="center"> - </td>
<td width="30%" align="left">r0_Cmd</td>
</tr>
<tr>
<td width="25%" align="left"> 撤销结果</td>
<td width="5%" align="center"> : </td>
<td width="35%" align="left"> <?php echo $arr['r1_Code'];?> </td>
<td width="5%" align="center"> - </td>
<td width="30%" align="left">r1_Code</td>
</tr>
</table>
</body>
</html>
|
apache-2.0
|
srdo/storm
|
storm-client/src/jvm/org/apache/storm/trident/tuple/ComboList.java
|
2903
|
/**
* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version
* 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package org.apache.storm.trident.tuple;
import java.io.Serializable;
import java.util.AbstractList;
import java.util.List;
import org.apache.commons.lang.builder.ToStringBuilder;
public class ComboList extends AbstractList<Object> {
Pointer[] _index;
List[] _delegates;
public ComboList(List[] delegates, Pointer[] index) {
_index = index;
_delegates = delegates;
}
@Override
public Object get(int i) {
Pointer ptr = _index[i];
return _delegates[ptr.listIndex].get(ptr.subIndex);
}
@Override
public int size() {
return _index.length;
}
public static class Factory implements Serializable {
Pointer[] index;
int[] sizes;
public Factory(int... sizes) {
this.sizes = sizes;
int total = 0;
for (int size : sizes) {
total += size;
}
index = new Pointer[total];
int i = 0;
int j = 0;
for (int size : sizes) {
for (int z = 0; z < size; z++) {
index[j] = new Pointer(i, z);
j++;
}
i++;
}
}
public ComboList create(List[] delegates) {
if (delegates.length != sizes.length) {
throw new RuntimeException("Expected " + sizes.length + " lists, but instead got " + delegates.length + " lists");
}
for (int i = 0; i < delegates.length; i++) {
List l = delegates[i];
if (l == null || l.size() != sizes[i]) {
throw new RuntimeException("Got unexpected delegates to ComboList: " + ToStringBuilder.reflectionToString(delegates));
}
}
return new ComboList(delegates, index);
}
}
private static class Pointer implements Serializable {
int listIndex;
int subIndex;
public Pointer(int listIndex, int subIndex) {
this.listIndex = listIndex;
this.subIndex = subIndex;
}
}
}
|
apache-2.0
|
todbot/Blink1Control2
|
app/server/mailService.js
|
2101
|
/**
* Fetch results from various types of mail services
*
* It needs to do:
* - Load mail configuration from global config
* - Run a MailSearcher for each unique user/server pair (could map to multiple rules)
*
* - When a new event happens
* -- log the event
* -- trigger the pattern (hmm, this means this needs access to PatternsApi)
* --
*
*
*
*
*
*
*/
"use strict";
var conf = require('../configuration');
var log = require('../logger');
var ImapSearcher = require('./imapSearcher');
// var PopSearcher = require('./popSearcher');
// var PatternsService = require('./patternsService');
// globals because we are a singleton
// var listeners = {};
var MailService = {
config: {},
rules: [],
searchers: [],
start: function() {
log.msg("MailService.start");
this.setupSearchers();
},
stop: function() {
this.searchers.map( function(searcher) {
searcher.stop();
});
},
reloadConfig: function() {
this.stop();
this.start();
},
setupSearchers: function() {
var self = this;
self.config = conf.readSettings('eventServices:mailService');
if( self.config.enable === false ) { return; }
var allrules = conf.readSettings('eventRules') || [];
self.rules = allrules.filter( function(r){return r.type==='mail';} );
log.msg("MailService.checkMail. rules=", self.rules);
if( !self.rules ) {
self.rules = [];
}
self.searchers = []; // FIXME: hmmm
self.rules.map( function(rule) {
if( rule.enabled && (rule.mailtype === 'IMAP' || rule.mailtype === 'GMAIL') ) {
var searcher = new ImapSearcher( rule ); //, self.handleResults.bind(self) );
log.msg("MailService.checkMail: starting searcher for ",rule.name, "current searchers:",self.searchers);
searcher.start();
self.searchers.push( searcher );
// FIXME: merge rules for same mail server?43
}
});
}
};
module.exports = MailService;
|
apache-2.0
|
dasomel/egovframework
|
common-component/v2.3.2/src/main/java/egovframework/com/sym/sym/nwk/service/impl/EgovNtwrkServiceImpl.java
|
2801
|
/**
* 개요
* - 네트워크에 대한 ServiceImpl 클래스를 정의한다.
*
* 상세내용
* - 네트워크에 대한 등록, 수정, 삭제, 조회 기능을 제공한다.
* - 네트워크의 조회기능은 목록조회, 상세조회로 구분된다.
* @author lee.m.j
* @version 1.0
* @created 19-8-2010 오후 4:34:35
*/
package egovframework.com.sym.sym.nwk.service.impl;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import egovframework.com.sym.sym.nwk.service.EgovNtwrkService;
import egovframework.com.sym.sym.nwk.service.Ntwrk;
import egovframework.com.sym.sym.nwk.service.NtwrkVO;
import egovframework.com.utl.fcc.service.EgovStringUtil;
import egovframework.rte.fdl.cmmn.AbstractServiceImpl;
@Service("egovNtwrkService")
public class EgovNtwrkServiceImpl extends AbstractServiceImpl implements EgovNtwrkService {
@Resource(name="ntwrkDAO")
private NtwrkDAO ntwrkDAO;
/**
* 네트워크를 관리하기 위해 등록된 네트워크목록을 조회한다.
* @param ntwrkVO - 네트워크 Vo
* @return List - 네트워크 목록
*/
@SuppressWarnings("unchecked")
public List<NtwrkVO> selectNtwrkList(NtwrkVO ntwrkVO) throws Exception {
return ntwrkDAO.selectNtwrkList(ntwrkVO);
}
/**
* 네트워크목록 총 갯수를 조회한다.
* @param ntwrkVO - 네트워크 Vo
* @return int - 네트워크 카운트 수
*/
public int selectNtwrkListTotCnt(NtwrkVO ntwrkVO) throws Exception {
return ntwrkDAO.selectNtwrkListTotCnt(ntwrkVO);
}
/**
* 등록된 네트워크의 상세정보를 조회한다.
* @param ntwrkVO - 네트워크 Vo
* @return NtwrkVO - 네트워크 Vo
*/
public NtwrkVO selectNtwrk(NtwrkVO ntwrkVO) throws Exception {
return ntwrkDAO.selectNtwrk(ntwrkVO);
}
/**
* 네트워크정보를 신규로 등록한다.
* @param ntwrk - 네트워크 model
* @return NtwrkVO - 네트워크 Vo
*/
public NtwrkVO insertNtwrk(Ntwrk ntwrk, NtwrkVO ntwrkVO) throws Exception {
ntwrk.setRegstYmd(EgovStringUtil.removeMinusChar(ntwrk.getRegstYmd()));
ntwrkDAO.insertNtwrk(ntwrk);
ntwrkVO.setNtwrkId(ntwrk.getNtwrkId());
return ntwrkDAO.selectNtwrk(ntwrkVO);
}
/**
* 기 등록된 네트워크정보를 수정한다.
* @param ntwrk - 네트워크 model
*/
public void updateNtwrk(Ntwrk ntwrk) throws Exception {
ntwrk.setRegstYmd(EgovStringUtil.removeMinusChar(ntwrk.getRegstYmd()));
ntwrkDAO.updateNtwrk(ntwrk);
}
/**
* 기 등록된 네트워크정보를 삭제한다.
* @param ntwrk - 네트워크 model
*/
public void deleteNtwrk(Ntwrk ntwrk) throws Exception {
ntwrkDAO.deleteNtwrk(ntwrk);
}
}
|
apache-2.0
|
celigo/netsuite-service-manager-dotnet
|
ServiceManager/SuiteTalk/CurrencyRateSearchRowBasic.cs
|
224
|
//~ Generated by SearchRowBasicTemplate.tt
#pragma warning disable 1591
using System;
namespace com.celigo.net.ServiceManager.SuiteTalk
{
public partial class CurrencyRateSearchRowBasic : ISearchRowBasic
{
}
}
|
apache-2.0
|
aws/aws-sdk-java
|
aws-java-sdk-cloudsearch/src/main/java/com/amazonaws/services/cloudsearchv2/model/LimitExceededException.java
|
1252
|
/*
* Copyright 2017-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.cloudsearchv2.model;
import javax.annotation.Generated;
/**
* <p>
* The request was rejected because a resource limit has already been met.
* </p>
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class LimitExceededException extends com.amazonaws.services.cloudsearchv2.model.AmazonCloudSearchException {
private static final long serialVersionUID = 1L;
/**
* Constructs a new LimitExceededException with the specified error message.
*
* @param message
* Describes the error encountered.
*/
public LimitExceededException(String message) {
super(message);
}
}
|
apache-2.0
|
pstorch/cgeo
|
tests/src-android/cgeo/watchdog/WatchdogTest.java
|
4166
|
package cgeo.watchdog;
import static org.assertj.core.api.Java6Assertions.assertThat;
import cgeo.CGeoTestCase;
import cgeo.geocaching.SearchResult;
import cgeo.geocaching.connector.ConnectorFactory;
import cgeo.geocaching.connector.IConnector;
import cgeo.geocaching.connector.oc.OCApiConnector;
import cgeo.geocaching.connector.trackable.TrackableConnector;
import cgeo.geocaching.enumerations.LoadFlags;
import cgeo.geocaching.models.Geocache;
import cgeo.geocaching.network.Network;
import cgeo.geocaching.test.NotForIntegrationTests;
import org.apache.commons.lang3.StringUtils;
/**
* This test is intended to run regularly on our CI server, to verify the availability of several geocaching websites
* and our ability to parse a cache from it.
* <p>
* You need all the opencaching API keys for this test to run.
* </p>
*
*/
public class WatchdogTest extends CGeoTestCase {
@NotForIntegrationTests
public static void testOpenCachingDE() {
downloadOpenCaching("OC1234");
}
@NotForIntegrationTests
public static void testOpenCachingNL() {
downloadOpenCaching("OB1AF6");
}
@NotForIntegrationTests
public static void testOpenCachingPL() {
downloadOpenCaching("OP89HC");
}
@NotForIntegrationTests
public static void testOpenCachingRO() {
downloadOpenCaching("OR011D");
}
@NotForIntegrationTests
public static void testOpenCacheUK() {
downloadOpenCaching("OK0384");
}
@NotForIntegrationTests
public static void testOpenCachingUS() {
downloadOpenCaching("OU0331");
}
private static void downloadOpenCaching(final String geocode) {
final OCApiConnector connector = (OCApiConnector) ConnectorFactory.getConnector(geocode);
assertThat(connector).overridingErrorMessage("Did not find c:geo connector for %s", geocode).isNotNull();
final SearchResult searchResult = connector.searchByGeocode(geocode, null, null);
assertThat(searchResult).overridingErrorMessage("Failed to get response from %s", connector.getName()).isNotNull();
assertThat(searchResult.getCount()).overridingErrorMessage("Failed to download %s from %s", geocode, connector.getName()).isGreaterThan(0);
final Geocache geocache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB);
assertThat(geocache).isNotNull();
assert geocache != null; // Eclipse null analysis weakness
assertThat(geocache.getGeocode()).isEqualTo(geocode);
}
private static void checkWebsite(final String connectorName, final String url) {
// temporarily disable oc.uk
if (connectorName.equalsIgnoreCase("geocaching website opencache.uk")) {
return;
}
// temporarily disable extremcaching.com
if (connectorName.equalsIgnoreCase("geocaching website extremcaching.com")) {
return;
}
final String page = Network.getResponseData(Network.getRequest(url));
assertThat(page).overridingErrorMessage("Failed to get response from " + connectorName).isNotEmpty();
}
@NotForIntegrationTests
public static void testTrackableWebsites() {
for (final TrackableConnector trackableConnector : ConnectorFactory.getTrackableConnectors()) {
if (!trackableConnector.equals(ConnectorFactory.UNKNOWN_TRACKABLE_CONNECTOR)) {
checkWebsite("trackable website " + trackableConnector.getHost(), trackableConnector.getTestUrl());
if (StringUtils.isNotBlank(trackableConnector.getProxyUrl())) {
checkWebsite("trackable website " + trackableConnector.getHost() + " proxy " + trackableConnector.getProxyUrl(), trackableConnector.getProxyUrl());
}
}
}
}
@NotForIntegrationTests
public static void testGeocachingWebsites() {
for (final IConnector connector : ConnectorFactory.getConnectors()) {
if (!connector.equals(ConnectorFactory.UNKNOWN_CONNECTOR)) {
checkWebsite("geocaching website " + connector.getName(), connector.getTestUrl());
}
}
}
}
|
apache-2.0
|
ericschultz/visitor-pattern
|
VisitorPattern.Automation/Commands/LoadStart.cs
|
1682
|
using System;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using NuPattern;
using NuPattern.Diagnostics;
using NuPattern.Runtime;
namespace VisitorPattern.Automation.Commands
{
/// <summary>
/// A custom command that performs some automation.
/// </summary>
/// <summary>
/// A custom command that performs some automation.
/// </summary>
[DisplayName("LoadStart")]
[Category("General")]
[Description("This command creates the Projects element")]
[CLSCompliant(false)]
public class LoadStart : NuPattern.Runtime.Command
{
private static readonly ITracer tracer = Tracer.Get<LoadStart>();
/// <summary>
/// Gets or sets the current element.
/// </summary>
[Required]
[Import(AllowDefault = true)]
public IVisitorPattern CurrentElement { get; set; }
/// <summary>
/// This command creates the Projects element
/// </summary>
/// <remarks></remarks>
public override void Execute()
{
tracer.Warn(
"Executing LoadProjects on current View defaultView");
// Verify all [Required] and [Import]ed properties have valid values.
this.ValidateObject();
// Make initial trace statement for this command
tracer.Info(
"Executing LoadProjects on current View defaultView");
if (CurrentElement.DefaultView.Projects == null)
{
CurrentElement.DefaultView.CreateProjects("Projects");
}
}
}
}
|
apache-2.0
|
shimat/opencvsharp
|
src/OpenCvSharp/Modules/ximgproc/EdgeFilter/DTFilter.cs
|
4071
|
using System;
using OpenCvSharp.Internal;
// ReSharper disable once CheckNamespace
namespace OpenCvSharp.XImgProc
{
/// <summary>
/// Interface for realizations of Domain Transform filter.
/// </summary>
// ReSharper disable once InconsistentNaming
public class DTFilter : Algorithm
{
private Ptr? detectorPtr;
/// <summary>
/// Creates instance by raw pointer
/// </summary>
protected DTFilter(IntPtr p)
{
detectorPtr = new Ptr(p);
ptr = detectorPtr.Get();
}
/// <summary>
/// Releases managed resources
/// </summary>
protected override void DisposeManaged()
{
detectorPtr?.Dispose();
detectorPtr = null;
base.DisposeManaged();
}
/// <summary>
/// Factory method, create instance of DTFilter and produce initialization routines.
/// </summary>
/// <param name="guide">guided image (used to build transformed distance, which describes edge structure of
/// guided image).</param>
/// <param name="sigmaSpatial">sigma_H parameter in the original article, it's similar to the sigma in the
/// coordinate space into bilateralFilter.</param>
/// <param name="sigmaColor">sigma_r parameter in the original article, it's similar to the sigma in the
/// color space into bilateralFilter.</param>
/// <param name="mode">one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for
/// filtering 2D signals in the article.</param>
/// <param name="numIters">optional number of iterations used for filtering, 3 is quite enough.</param>
/// <returns></returns>
public static DTFilter Create(
InputArray guide, double sigmaSpatial, double sigmaColor,
EdgeAwareFiltersList mode = EdgeAwareFiltersList.DTF_NC, int numIters = 3)
{
if (guide == null)
throw new ArgumentNullException(nameof(guide));
guide.ThrowIfDisposed();
NativeMethods.HandleException(
NativeMethods.ximgproc_createDTFilter(
guide.CvPtr, sigmaSpatial, sigmaColor, (int)mode, numIters, out var p));
GC.KeepAlive(guide);
return new DTFilter(p);
}
/// <summary>
/// Simple one-line Domain Transform filter call. If you have multiple images to filter with the same
/// guided image then use DTFilter interface to avoid extra computations on initialization stage.
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
/// <param name="dDepth"></param>
public virtual void Filter(InputArray src, OutputArray dst, int dDepth = -1)
{
ThrowIfDisposed();
if (src == null)
throw new ArgumentNullException(nameof(src));
if (dst == null)
throw new ArgumentNullException(nameof(dst));
src.ThrowIfDisposed();
dst.ThrowIfNotReady();
NativeMethods.HandleException(
NativeMethods.ximgproc_DTFilter_filter(
ptr, src.CvPtr, dst.CvPtr, dDepth));
GC.KeepAlive(this);
GC.KeepAlive(src);
dst.Fix();
}
internal class Ptr : OpenCvSharp.Ptr
{
public Ptr(IntPtr ptr) : base(ptr)
{
}
public override IntPtr Get()
{
NativeMethods.HandleException(
NativeMethods.ximgproc_Ptr_DTFilter_get(ptr, out var ret));
GC.KeepAlive(this);
return ret;
}
protected override void DisposeUnmanaged()
{
NativeMethods.HandleException(
NativeMethods.ximgproc_Ptr_DTFilter_delete(ptr));
base.DisposeUnmanaged();
}
}
}
}
|
apache-2.0
|
vvutharkar/kafka-manager
|
app/models/form/TopicOperation.scala
|
567
|
/**
* Copyright 2015 Yahoo Inc. Licensed under the Apache License, Version 2.0
* See accompanying LICENSE file.
*/
package models.form
/**
* @author hiral
*/
sealed trait TopicOperation
case class TConfig(name: String, value: Option[String])
case class CreateTopic(topic: String, partitions: Int, replication: Int, configs: List[TConfig]) extends TopicOperation
case class DeleteTopic(topic: String) extends TopicOperation
case class AlterTopic(topic: String, partitions: Int) extends TopicOperation
case class UnknownTO(op: String) extends TopicOperation
|
apache-2.0
|
CSCSI/Triana
|
triana-types/src/main/java/triana/types/audio/AudioEffect.java
|
11437
|
/*
* The University of Wales, Cardiff Triana Project Software License (Based
* on the Apache Software License Version 1.1)
*
* Copyright (c) 2007 University of Wales, Cardiff. All rights reserved.
*
* Redistribution and use of the software in source and binary forms, with
* or without modification, are permitted provided that the following
* conditions are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. The end-user documentation included with the redistribution, if any,
* must include the following acknowledgment: "This product includes
* software developed by the University of Wales, Cardiff for the Triana
* Project (http://www.trianacode.org)." Alternately, this
* acknowledgment may appear in the software itself, if and wherever
* such third-party acknowledgments normally appear.
*
* 4. The names "Triana" and "University of Wales, Cardiff" must not be
* used to endorse or promote products derived from this software
* without prior written permission. For written permission, please
* contact triana@trianacode.org.
*
* 5. Products derived from this software may not be called "Triana," nor
* may Triana appear in their name, without prior written permission of
* the University of Wales, Cardiff.
*
* 6. This software may not be sold, used or incorporated into any product
* for sale to third parties.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
* NO EVENT SHALL UNIVERSITY OF WALES, CARDIFF OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
* ------------------------------------------------------------------------
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Triana Project. For more information on the
* Triana Project, please see. http://www.trianacode.org.
*
* This license is based on the BSD license as adopted by the Apache
* Foundation and is governed by the laws of England and Wales.
*
*/
package triana.types.audio;
/**
* AudioEffect : a base class for creating audio effect that work on chunks of data. The idea behind this class is to
* make it convenient for operating on a chunk by chunk basis. Most algorithms operate on a continuous stream of
* samples or on a specific sized amount of data where no memory is required for future use. This class provides a
* backwards and forward memory that you can initialise and use with your algorithm. For example a reverb or echo
* effect may require future memory for storing the echos or reverberations within that may be added or multiplied with
* the next data to be processed.
* <p/>
* You can set the size of the previous and next memory chunks. Care must be taken that you don't go out of the bounds
* of the maximum forward and backward memory.
* <p/>
* When new data arrives it is inserted into an array with the previous and forward data memory prepended and appended
* to it. By default the previous locations are filled with the previous data (i.e. the current data will be copied into
* it for the next iteration) and the forward data locations can either be added to the next data processed or
* multiplied to them. The default mode is to add the values to the next data set that arrives. NOTE that you must take
* care to set the initial values so that they don't effect the first data set i.e. If you're adding then initialse
* Forward values to 0 or Multiplying set them to 1.
* <p/>
* Process the next data chunk by calling preProcess and then get access to the the data array and the starting point by
* calling getData() and getStart(), respectively. Call postProcess to get the new data in the appropriate dimension.
* <p/>
* NOTE : This class currently assumes that the previous and forward memory sizes are the the same size or smaller than
* the current chunk of data. FUTURE extensions could involve allowing extended lengths of the previous and forward
* memory sizes. I think that this covers most applications however except things like Large Hall Reverb which can
* produce an effect that may span several future data sets.
*
* @author Ian Taylor
* @version $Revision: 4048 $
*/
public abstract class AudioEffect {
/**
* An identifier for adding the forward memory locations to the next data received by an AudioEffect. Use
* setForwardMathOperation to set the forward math mode.
*
* @see #setForwardMathOperation(int)
*/
public final static int ADD = 0;
/**
* An identifier for multiplying the forward memory locations to the next data received by an AudioEffect. Use
* setForwardMathOperation to set the forward math mode.
*
* @see #setForwardMathOperation(int)
*/
public final static int MULTIPLY = 1;
/**
* An identifier for ignoring the forward memory locations when receiving future inputs. Use setForwardMathOperation
* to set the forward math mode.
*
* @see #setForwardMathOperation(int)
*/
public final static int DO_NOTHING = 2;
// add by default.
private int mathMode = ADD;
private int currentSize = -1;
private double[] backwardMemory = null;
private double[] forwardMemory = null;
private double[] currentData = null;
private double[] givenData = null; // resuse the data that has been given for output
private int givenDataSize = -1;
private int startPos;
/**
* Creates an audio effect with a particular backward and forward memory size. Enter 0 for no memory in either
* direction.
*/
public AudioEffect(int backwardMemSize, int forwardMemSize) {
backwardMemory = new double[backwardMemSize];
forwardMemory = new double[forwardMemSize];
}
/**
* Initializes the previous memory values to the value specified.
*/
public void initialisePrevious(double val) {
for (int i = 0; i < backwardMemory.length; ++i) {
backwardMemory[i] = val;
}
}
/**
* Initializes the previous memory values to the values specified. The array given must be the same size as the size
* of the previous memory array otherwise the memory will not be initialized and an exception will be thrown
*/
public void initialisePrevious(double vals[]) throws IncompatibleSizeException {
if (vals.length != backwardMemory.length) {
throw new IncompatibleSizeException("Given vals array incompatible size with backwardMemory array");
}
for (int i = 0; i < backwardMemory.length; ++i) {
backwardMemory[i] = vals[i];
}
}
/**
* Initializes the forward memory values to the value specified.
*/
public void initialiseForward(double val) {
for (int i = 0; i < forwardMemory.length; ++i) {
forwardMemory[i] = val;
}
}
/**
* Initializes the forward values to the values specified. The array given must be the same size as the size of the
* previous memory array otherwise the memory will not be initialized and an exception will be thrown
*/
public void initialiseForward(double vals[]) throws IncompatibleSizeException {
if (vals.length != forwardMemory.length) {
throw new IncompatibleSizeException("Given vals array incompatible size with forwardMemory array");
}
for (int i = 0; i < forwardMemory.length; ++i) {
forwardMemory[i] = vals[i];
}
}
/**
* An function setting the behaviour of how AudioEffect applies the forward memory locations to the next data
* received by an AudioEffect. The default mode is ADD i.e. add them to the next data chunk but other can be
* specified e.g. MULTIPLY and DO_NOTHING
*/
public void setForwardMathOperation(int mode) {
this.mathMode = mode;
}
/**
* Gets the starting position of the current memory chunk with the previous and forward memory prepended and
* appended to it
*/
public int getStart() {
return startPos;
}
/**
* Gets data array
*/
public double[] getData() {
return currentData;
}
/**
* This function inserts the given data into an array which comprises of the previous data, the given data and the
* forward data respectively. To get a reference to the data use getData() and to get the starting point of the
* current data use getStart().
*/
public void preProcess(double data[]) {
// take a copy.
givenDataSize = data.length;
givenData = data;
int newSize = backwardMemory.length + data.length + forwardMemory.length;
if (currentSize != newSize) {
currentData = new double[newSize];
currentSize = newSize;
}
// copy backward memory
if (backwardMemory.length > 0) {
System.arraycopy(backwardMemory, 0, currentData, 0, backwardMemory.length);
}
// apply math operation to current samples.
if (forwardMemory.length > 0) {
if (mathMode == ADD) { // ONLY process the forwardMemory samples i.e. could be < data
for (int i = 0; i < forwardMemory.length; ++i) {
data[i] += forwardMemory[i];
}
} else if (mathMode == MULTIPLY) {
for (int i = 0; i < forwardMemory.length; ++i) {
data[i] *= forwardMemory[i];
}
}
}
// copy current memory
startPos = backwardMemory.length;
System.arraycopy(data, 0, currentData, startPos, data.length);
}
/**
* This function copies the current data to the forward memory for use next time and inserts the processed values
* back into the given array. The given array can be set to null and then the data is copied back into the ORGINAL
* array supplied. Otherwise, you can provide a non null array and the data is copied into this. The given array
* must be the same size as the one supplied to preProcess.
*/
public void postProcess(double data[]) throws IncompatibleSizeException {
if (data == null) {
data = givenData;
} else if (data.length != givenDataSize) {
throw new IncompatibleSizeException(
"postProcess : Given data array incompatible with array input to preProcess");
}
System.arraycopy(currentData, startPos, data, 0, data.length);
}
}
|
apache-2.0
|
cocoatomo/asakusafw
|
mapreduce/compiler/core/src/test/java/com/asakusafw/compiler/flow/example/MultiPublicConstructor.java
|
2322
|
/**
* Copyright 2011-2017 Asakusa Framework Team.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.asakusafw.compiler.flow.example;
import com.asakusafw.compiler.operator.model.MockFoo;
import com.asakusafw.compiler.operator.model.MockHoge;
import com.asakusafw.vocabulary.flow.Export;
import com.asakusafw.vocabulary.flow.FlowDescription;
import com.asakusafw.vocabulary.flow.Import;
import com.asakusafw.vocabulary.flow.In;
import com.asakusafw.vocabulary.flow.JobFlow;
import com.asakusafw.vocabulary.flow.Out;
/**
* A jobflow class w/ multiple public constructors.
*/
@JobFlow(name = "testing")
public class MultiPublicConstructor extends FlowDescription {
private final In<MockHoge> in;
private final Out<MockHoge> out;
/**
* Creates a new instance.
* @param in input
* @param out output
*/
public MultiPublicConstructor(
@Import(name = "hoge", description = MockHogeImporterDescription.class)
In<MockHoge> in,
@Export(name = "hoge", description = MockHogeExporterDescription.class)
Out<MockHoge> out) {
this.in = in;
this.out = out;
}
/**
* Creates a new instance.
* @param in input
* @param out output
* @param odd for constructor overload
*/
public MultiPublicConstructor(
@Import(name = "hoge", description = MockHogeImporterDescription.class)
In<MockHoge> in,
@Export(name = "hoge", description = MockHogeExporterDescription.class)
Out<MockHoge> out,
@Export(name = "foo", description = MockFooExporterDescription.class)
Out<MockFoo> odd) {
this.in = in;
this.out = out;
}
@Override
protected void describe() {
out.add(in);
}
}
|
apache-2.0
|
batmancn/TinySDNController
|
ACE_wrappers/tests/Cache_Map_Manager_Test.cpp
|
16992
|
//=============================================================================
/**
* @file Cache_Map_Manager_Test.cpp
*
* $Id: Cache_Map_Manager_Test.cpp 95790 2012-05-24 15:06:21Z shuston $
*
* This is a test of the <ACE_Cache_Map_Manager> and
* <ACE_Hash_Cache_Map_Manager> that illustrates how to use the
* forward and reverse iterators, as well as the purging and
* caching features.
*
*
* @author Kirthika Parameswaran <kirthika@cs.wustl.edu>
*/
//=============================================================================
#include "ace/OS_NS_string.h"
#include "ace/OS_Memory.h"
#include "ace/OS_NS_stdlib.h"
#include "ace/OS_NS_time.h"
#include "test_config.h"
#include "ace/Hash_Cache_Map_Manager_T.h"
#include "ace/Map_Manager.h"
#include "ace/Caching_Strategies_T.h"
#include "ace/Functor.h"
#include "ace/Get_Opt.h"
#include "Cache_Map_Manager_Test.h" // Hash_Key class defined in here
typedef size_t KEY;
typedef size_t VALUE;
typedef int ATTR;
typedef std::pair<VALUE, ATTR> CACHE_VALUE;
typedef ACE_Equal_To<KEY> COMPARE_KEYS;
typedef ACE_Hash_Map_Manager_Ex<KEY, CACHE_VALUE, Hash_Key, ACE_Equal_To<KEY>, ACE_Null_Mutex>
HASH_MAP_MANAGER;
typedef ACE_Hash_Map_Iterator_Ex<KEY, CACHE_VALUE, Hash_Key, ACE_Equal_To<KEY>, ACE_Null_Mutex>
HASH_MAP_ITERATOR;
typedef ACE_Hash_Map_Reverse_Iterator_Ex<KEY, CACHE_VALUE, Hash_Key, ACE_Equal_To<KEY>, ACE_Null_Mutex>
HASH_MAP_REVERSE_ITERATOR;
typedef ACE_Map_Manager<KEY, CACHE_VALUE, ACE_Null_Mutex>
MAP_MANAGER;
typedef ACE_Map_Iterator<KEY, CACHE_VALUE, ACE_Null_Mutex>
MAP_ITERATOR;
typedef ACE_Map_Reverse_Iterator<KEY, CACHE_VALUE, ACE_Null_Mutex>
MAP_REVERSE_ITERATOR;
typedef ACE_Cleanup_Strategy<KEY, CACHE_VALUE, HASH_MAP_MANAGER>
HASH_MAP_CLEANUP;
typedef ACE_Cleanup_Strategy<KEY, CACHE_VALUE, MAP_MANAGER>
MAP_CLEANUP;
typedef ACE_Pair_Caching_Utility<KEY, CACHE_VALUE, HASH_MAP_MANAGER, HASH_MAP_ITERATOR, ATTR>
HASH_MAP_CACHING_UTILITY;
typedef ACE_Pair_Caching_Utility<KEY, CACHE_VALUE, MAP_MANAGER, MAP_ITERATOR, ATTR>
MAP_CACHING_UTILITY;
// = Hash_Map_Manager related
typedef ACE_Caching_Strategy<ATTR, HASH_MAP_CACHING_UTILITY>
HASH_MAP_CACHING_STRATEGY;
typedef ACE_LRU_Caching_Strategy<ATTR, HASH_MAP_CACHING_UTILITY>
HASH_MAP_LRU;
typedef ACE_LFU_Caching_Strategy<ATTR, HASH_MAP_CACHING_UTILITY>
HASH_MAP_LFU;
typedef ACE_FIFO_Caching_Strategy<ATTR, HASH_MAP_CACHING_UTILITY>
HASH_MAP_FIFO;
typedef ACE_Null_Caching_Strategy<ATTR, HASH_MAP_CACHING_UTILITY>
HASH_MAP_NULL;
typedef ACE_Caching_Strategy_Adapter<ATTR, HASH_MAP_CACHING_UTILITY, HASH_MAP_LRU>
HASH_MAP_LRU_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, HASH_MAP_CACHING_UTILITY, HASH_MAP_LFU>
HASH_MAP_LFU_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, HASH_MAP_CACHING_UTILITY, HASH_MAP_FIFO>
HASH_MAP_FIFO_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, HASH_MAP_CACHING_UTILITY, HASH_MAP_NULL>
HASH_MAP_NULL_ADAPTER;
// = Map_Manager related
typedef ACE_Caching_Strategy<ATTR, MAP_CACHING_UTILITY>
MAP_CACHING_STRATEGY;
typedef ACE_LRU_Caching_Strategy<ATTR, MAP_CACHING_UTILITY>
MAP_LRU;
typedef ACE_LFU_Caching_Strategy<ATTR, MAP_CACHING_UTILITY>
MAP_LFU;
typedef ACE_FIFO_Caching_Strategy<ATTR, MAP_CACHING_UTILITY>
MAP_FIFO;
typedef ACE_Null_Caching_Strategy<ATTR, MAP_CACHING_UTILITY>
MAP_NULL;
typedef ACE_Caching_Strategy_Adapter<ATTR, MAP_CACHING_UTILITY, MAP_LRU>
MAP_LRU_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, MAP_CACHING_UTILITY, MAP_LFU>
MAP_LFU_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, MAP_CACHING_UTILITY, MAP_FIFO>
MAP_FIFO_ADAPTER;
typedef ACE_Caching_Strategy_Adapter<ATTR, MAP_CACHING_UTILITY, MAP_NULL>
MAP_NULL_ADAPTER;
typedef ACE_Hash_Cache_Map_Manager<KEY, VALUE, Hash_Key, ACE_Equal_To<KEY>, HASH_MAP_CACHING_STRATEGY, ATTR>
HASH_MAP_CACHE;
typedef ACE_Cache_Map_Manager<KEY, VALUE, MAP_MANAGER, MAP_ITERATOR, MAP_REVERSE_ITERATOR, MAP_CACHING_STRATEGY, ATTR>
MAP_CACHE;
enum Caching_Strategy_Type
{
ACE_LFU,
ACE_FIFO,
ACE_LRU,
ACE_NULL,
ACE_ALL
};
static size_t iterations = ACE_MAX_ITERATIONS;
static size_t no_of_lookups = iterations / 2;
static int randomize_lookups = 1;
static int purge_percent = 10;
static int debug = 0;
static Caching_Strategy_Type caching_strategy_type = ACE_ALL;
static KEY *lookup_array = 0;
static void
run_iterator_cache (MAP_CACHE &cache)
{
size_t iterations = cache.current_size ();
size_t counter = 0;
MAP_CACHE::iterator end = cache.end ();
for (MAP_CACHE::iterator iter = cache.begin ();
iter != end;
++iter)
{
// Debugging info.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d)"),
(*iter).first (),
(*iter).second ()));
ACE_TEST_ASSERT ((*iter).first () == (*iter).second ());
++counter;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
ACE_UNUSED_ARG (iterations);
ACE_TEST_ASSERT (counter == iterations);
}
static void
run_iterator_hash_cache (HASH_MAP_CACHE &cache)
{
size_t iterations = cache.current_size ();
size_t counter = 0;
HASH_MAP_CACHE::iterator end = cache.end ();
for (HASH_MAP_CACHE::iterator iter = cache.begin ();
iter != end;
++iter)
{
// Debugging info.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d)"),
(*iter).first (),
(*iter).second ()));
ACE_TEST_ASSERT ((*iter).first () == (*iter).second ());
++counter;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
ACE_UNUSED_ARG (iterations);
ACE_TEST_ASSERT (counter == iterations);
}
static void
run_reverse_iterator_cache (MAP_CACHE &cache)
{
size_t counter = cache.current_size ();
MAP_CACHE::reverse_iterator rend = cache.rend ();
for (MAP_CACHE::reverse_iterator iter = cache.rbegin ();
iter != rend;
++iter)
{
ACE_TEST_ASSERT ((*iter).first () == (*iter).second ());
// Debugging info.
if (debug)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d)"),
(*iter).first (),
(*iter).second ()));
--counter;
}
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
ACE_TEST_ASSERT (counter == 0);
}
static void
run_reverse_iterator_hash_cache (HASH_MAP_CACHE &cache)
{
size_t counter = cache.current_size ();
HASH_MAP_CACHE::reverse_iterator rend = cache.rend ();
for (HASH_MAP_CACHE::reverse_iterator iter = cache.rbegin ();
iter != rend;
++iter)
{
ACE_TEST_ASSERT ((*iter).first () == (*iter).second ());
// Debugging info.
if (debug)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d)"),
(*iter).first (),
(*iter).second ()));
--counter;
}
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
ACE_TEST_ASSERT (counter == 0);
}
static void
find_test_cache (MAP_CACHE &cache)
{
for (size_t i = 0; i < no_of_lookups; ++i)
{
VALUE j = 0;
int result = cache.find (lookup_array[i], j);
result = cache.find (lookup_array[i]);
ACE_TEST_ASSERT (result != -1);
ACE_TEST_ASSERT (j == lookup_array[i]);
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d "), j));
// Once more, with only the key. Test Bugzilla #4029.
result = cache.find (lookup_array[i]);
ACE_TEST_ASSERT (result != -1);
ACE_UNUSED_ARG (result);
}
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
}
static void
find_test_hash_cache (HASH_MAP_CACHE &cache)
{
for (size_t i = 0; i < no_of_lookups; ++i)
{
VALUE j = 0;
int result = cache.find (lookup_array[i], j);
ACE_TEST_ASSERT (result != -1);
ACE_TEST_ASSERT (j == lookup_array[i]);
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d "), j));
ACE_UNUSED_ARG (result);
}
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n")));
}
static void
purge_test_cache (MAP_CACHE &cache)
{
// Get the number of entries in the container.
size_t current_map_size = cache.current_size ();
// Find the number of entries which will get purged.
size_t entries_to_remove = size_t ((double (purge_percent) / 100 * current_map_size) + 0.5);
// Tell the caching strategy how much to purge.
cache.caching_strategy ().purge_percent (purge_percent);
// Purge from cache.
int result = cache.purge ();
ACE_TEST_ASSERT (result != -1);
ACE_UNUSED_ARG (result);
size_t resultant_size = 0;
if (caching_strategy_type == ACE_NULL)
resultant_size = current_map_size;
else
resultant_size = current_map_size - entries_to_remove;
// Make sure the purge took out the appropriate number of entries.
ACE_TEST_ASSERT (cache.current_size () == resultant_size);
ACE_UNUSED_ARG (resultant_size);
}
static void
purge_test_hash_cache (HASH_MAP_CACHE &cache)
{
// Get the number of entries in the container.
size_t current_map_size = cache.current_size ();
// Find the number of entries which will get purged.
size_t entries_to_remove = size_t ((double (purge_percent) / 100 * current_map_size) + 0.5);
// Tell the caching strategy how much to purge.
cache.caching_strategy ().purge_percent (purge_percent);
// Purge from cache.
int result = cache.purge ();
ACE_TEST_ASSERT (result != -1);
ACE_UNUSED_ARG (result);
size_t resultant_size = 0;
if (caching_strategy_type == ACE_NULL)
resultant_size = current_map_size;
else
resultant_size = current_map_size - entries_to_remove;
// Make sure the purge took out the appropriate number of entries.
ACE_TEST_ASSERT (cache.current_size () == resultant_size);
ACE_UNUSED_ARG (resultant_size);
}
static void
functionality_test_cache (MAP_CACHING_STRATEGY &caching_strategy)
{
MAP_CACHE cache (caching_strategy);
KEY i = 0;
VALUE j = 0;
// Add it to the map now.
for (size_t counter = 0;
i < iterations;
++i, ++j)
{
int result = cache.bind (i, j);
ACE_TEST_ASSERT (result == 0);
ACE_UNUSED_ARG (result);
if (debug)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("keys[%d]=%d value=[%d]=%d\n"),
i, i, j, j));
++counter;
ACE_TEST_ASSERT (cache.current_size () == counter);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Number of entries in cache before purging: %d\n"),
cache.current_size ()));
run_iterator_cache (cache);
run_reverse_iterator_cache (cache);
find_test_cache (cache);
purge_test_cache (cache);
run_iterator_cache (cache);
run_reverse_iterator_cache (cache);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Number of entries in cache after purging: %d\n"),
cache.current_size ()));
}
static void
functionality_test_hash_cache (HASH_MAP_CACHING_STRATEGY &caching_strategy)
{
HASH_MAP_CACHE cache (caching_strategy);
KEY i = 0;
VALUE j = 0;
// Add it to the map now.
for (size_t counter = 0;
i < iterations;
++i, ++j)
{
int result = cache.bind (i, j);
ACE_TEST_ASSERT (result == 0);
ACE_UNUSED_ARG (result);
if (debug)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("keys[%d]=%d value=[%d]=%d\n"),
i, i, j, j));
++counter;
ACE_TEST_ASSERT (cache.current_size () == counter);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Number of entries in cache before purging: %d\n"),
cache.current_size ()));
run_iterator_hash_cache (cache);
run_reverse_iterator_hash_cache (cache);
find_test_hash_cache (cache);
purge_test_hash_cache (cache);
run_iterator_hash_cache (cache);
run_reverse_iterator_hash_cache (cache);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Number of entries in cache after purging: %d\n"),
cache.current_size ()));
}
void
test_caching_strategy_type (void)
{
HASH_MAP_CACHING_STRATEGY *hash_map_caching_strategy = 0;
MAP_CACHING_STRATEGY *map_caching_strategy = 0;
switch (caching_strategy_type)
{
case ACE_NULL:
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nNull_Caching_Strategy\n\n")));
ACE_NEW (map_caching_strategy,
MAP_NULL_ADAPTER);
ACE_NEW (hash_map_caching_strategy,
HASH_MAP_NULL_ADAPTER);
break;
case ACE_LRU:
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nLRU_Caching_Strategy\n\n")));
ACE_NEW (map_caching_strategy,
MAP_LRU_ADAPTER);
ACE_NEW (hash_map_caching_strategy,
HASH_MAP_LRU_ADAPTER);
break;
case ACE_LFU:
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nLFU_Caching_Strategy\n\n")));
ACE_NEW (map_caching_strategy,
MAP_LFU_ADAPTER);
ACE_NEW (hash_map_caching_strategy,
HASH_MAP_LFU_ADAPTER);
break;
case ACE_FIFO:
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nFIFO_Caching_Strategy\n\n")));
ACE_NEW (map_caching_strategy,
MAP_FIFO_ADAPTER);
ACE_NEW (hash_map_caching_strategy,
HASH_MAP_FIFO_ADAPTER);
break;
case ACE_ALL: // Just to remove warnings!
break;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("map cache\n")));
functionality_test_cache (*map_caching_strategy);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nhash map cache\n")));
functionality_test_hash_cache (*hash_map_caching_strategy);
delete map_caching_strategy;
delete hash_map_caching_strategy;
}
static int
parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("c:i:r:f:p:d"));
int cc;
while ((cc = get_opt ()) != -1)
{
switch (cc)
{
case 'c':
if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("null")) == 0)
caching_strategy_type = ACE_NULL;
if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("lru")) == 0)
caching_strategy_type = ACE_LRU;
if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("lfu")) == 0)
caching_strategy_type = ACE_LFU;
if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("fifo")) == 0)
caching_strategy_type = ACE_FIFO;
break;
case 'i':
iterations = ACE_OS::atoi (get_opt.opt_arg ());
break;
case 'f':
no_of_lookups = ACE_OS::atoi (get_opt.opt_arg ());
break;
case 'r':
randomize_lookups = ACE_OS::atoi (get_opt.opt_arg ());
break;
case 'p':
purge_percent = ACE_OS::atoi (get_opt.opt_arg ());
break;
case 'd':
debug = 1;
break;
case '?':
case 'h':
default:
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("usage: %s ")
ACE_TEXT ("[-c (caching strategy: lru / lfu / fifo / null [default = all])] ")
ACE_TEXT ("[-r (randomize lookups)] ")
ACE_TEXT ("[-i (iterations)] ")
ACE_TEXT ("[-d (debug, i.e., addition printouts)] ")
ACE_TEXT ("[-p (purge percent)] ")
ACE_TEXT ("[-f (number of lookups)]\n"),
ACE_TEXT ("Cache_Map_Manager_Test")));
return -1;
}
}
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
// Validate options.
int result = parse_args (argc, argv);
if (result != 0)
return result;
// Start the test only if options are valid.
ACE_START_TEST (ACE_TEXT ("Cache_Map_Manager_Test"));
// Remove the extra debugging attributes from Log_Msg output.
ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
// Providing random a unique seed.
ACE_OS::srand (static_cast<u_int> (ACE_OS::time (0)));
// Create the lookup array.
ACE_NEW_RETURN (lookup_array,
KEY[no_of_lookups],
-1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nLookup sequence: ")));
// Initialize the lookup array.
for (size_t k = 0;
k < no_of_lookups;
++k)
{
if (randomize_lookups != 0)
lookup_array[k] = ACE_OS::rand () % iterations;
else
lookup_array[k] = k % iterations;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%d "),
lookup_array[k]));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n\n")));
// Do we need to test all the strategies.
if (caching_strategy_type == ACE_ALL)
{
caching_strategy_type = ACE_NULL;
test_caching_strategy_type ();
caching_strategy_type = ACE_LRU;
test_caching_strategy_type ();
caching_strategy_type = ACE_LFU;
test_caching_strategy_type ();
caching_strategy_type = ACE_FIFO;
test_caching_strategy_type ();
}
else
{
test_caching_strategy_type ();
}
delete[] lookup_array;
ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE);
ACE_END_TEST;
return 0;
}
|
apache-2.0
|
Arvis-Home/zigbee4java
|
zigbee-api/src/main/java/org/bubblecloud/zigbee/network/discovery/LinkQualityIndicatorNetworkBrowser.java
|
16631
|
/*
Copyright 2012-2013 CNR-ISTI, http://isti.cnr.it
Institute of Information Science and Technologies
of the Italian National Research Council
See the NOTICE file distributed with this work for additional
information regarding copyright ownership
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package org.bubblecloud.zigbee.network.discovery;
import org.bubblecloud.zigbee.network.ZigBeeNetworkManager;
import org.bubblecloud.zigbee.network.impl.ZigBeeNetwork;
import org.bubblecloud.zigbee.network.packet.ZToolAddress16;
import org.bubblecloud.zigbee.network.packet.zdo.ZDO_IEEE_ADDR_REQ;
import org.bubblecloud.zigbee.network.packet.zdo.ZDO_IEEE_ADDR_RSP;
import org.bubblecloud.zigbee.network.packet.zdo.ZDO_MGMT_LQI_REQ;
import org.bubblecloud.zigbee.network.packet.zdo.ZDO_MGMT_LQI_RSP;
import org.bubblecloud.zigbee.network.packet.zdo.ZDO_MGMT_LQI_RSP.NeighborLqiListItemClass;
import org.bubblecloud.zigbee.util.Integers;
import org.bubblecloud.zigbee.util.RunnableThread;
import org.bubblecloud.zigbee.util.ThreadUtils;
import org.bubblecloud.zigbee.network.ZigBeeNode;
import org.bubblecloud.zigbee.network.impl.ApplicationFrameworkLayer;
import org.bubblecloud.zigbee.network.impl.ZigBeeNodeImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
* Performs a scan of the network getting the Link Quality Information for the different
* links. If a new device is found, then it's added to the network.
* <p>
* Also keeps statistics of the LQI information to allow this to be provided to the user
* to establish and monitor network quality.
*
* @author <a href="mailto:stefano.lenzi@isti.cnr.it">Stefano "Kismet" Lenzi</a>
* @author <a href="mailto:francesco.furfari@isti.cnr.it">Francesco Furfari</a>
* @author <a href="mailto:manlio.bacco@isti.cnr.it">Manlio Bacco</a>
* @author <a href="mailto:chris@cd-jackson.com">Chris Jackson</a>
* @since 0.7.0
*/
public class LinkQualityIndicatorNetworkBrowser extends RunnableThread {
private static final Logger logger = LoggerFactory.getLogger(LinkQualityIndicatorNetworkBrowser.class);
private static final short COORDINATOR_NWK_ADDRESS = 0;
private static final short LQI_START_INDEX = 0;
private final ImportingQueue queue;
final ZigBeeNetworkManager driver;
final ArrayList<NetworkAddressNodeItem> toInspect = new ArrayList<NetworkAddressNodeItem>();
final HashMap<Integer, NetworkAddressNodeItem> alreadyInspected = new HashMap<Integer, NetworkAddressNodeItem>();
private NetworkNeighbourLinks connectedNodeLinks = new NetworkNeighbourLinks();
/**
* This class maintains the link quality information for all nodes and links on the network.
*
* TODO: Add methods to remove stale information
*/
public class NetworkNeighbourLinks {
private class NetworkLQI {
private int lqiMin = 255;
private int lqiMax = 0;
private int lqiLast;
private int total = 0;
private int count = 0;
void updateLQI(int lqi) {
if(lqi < lqiMin) {
lqiMin = lqi;
}
if(lqi > lqiMax) {
lqiMax = lqi;
}
lqiLast = lqi;
count++;
total += lqi;
}
int getLast() {
return lqiLast;
}
int getMin() {
return lqiMin;
}
int getMax() {
return lqiMax;
}
int getAvg() {
return total / count;
}
}
private Map<Integer, TreeMap<Integer, NetworkLQI>> lqiStatistics = new TreeMap<Integer, TreeMap<Integer, NetworkLQI>>();
public void updateLQI(int source, int dest, int lqi) {
TreeMap<Integer, NetworkLQI> srcMap = lqiStatistics.get(source);
if(srcMap == null) {
srcMap = new TreeMap<Integer, NetworkLQI>();
lqiStatistics.put(source, srcMap);
}
NetworkLQI dstMap = srcMap.get(dest);
if(dstMap == null) {
dstMap = new NetworkLQI();
srcMap.put(dest, dstMap);
}
dstMap.updateLQI(lqi);
}
private NetworkLQI getLink(int source, int dest) {
TreeMap<Integer, NetworkLQI> srcMap = lqiStatistics.get(source);
if(srcMap == null) {
return null;
}
NetworkLQI dstMap = srcMap.get(dest);
if(dstMap == null) {
return null;
}
return dstMap;
}
public int getLast(int source, int dest) {
NetworkLQI dstMap = getLink(source, dest);
if(dstMap == null) {
return -1;
}
return dstMap.getLast();
}
public int getMin(int source, int dest) {
NetworkLQI dstMap = getLink(source, dest);
if(dstMap == null) {
return -1;
}
return dstMap.getMin();
}
public int getMax(int source, int dest) {
NetworkLQI dstMap = getLink(source, dest);
if(dstMap == null) {
return -1;
}
return dstMap.getMax();
}
public int getAvg(int source, int dest) {
NetworkLQI dstMap = getLink(source, dest);
if(dstMap == null) {
return -1;
}
return dstMap.getAvg();
}
}
private class NetworkAddressNodeItem {
final NetworkAddressNodeItem parent;
final short address;
int lqi = -1;
ZigBeeNodeImpl node = null;
NetworkAddressNodeItem(NetworkAddressNodeItem addressTreeParent, short networkAddress) {
parent = addressTreeParent;
address = networkAddress;
}
NetworkAddressNodeItem(NetworkAddressNodeItem addressTreeParent, short networkAddress, int quality) {
parent = addressTreeParent;
address = networkAddress;
lqi = quality;
}
public int getParent() {
return parent.address;
}
public int getAddress() {
return address;
}
public int getLqi() {
return lqi;
}
public String toString() {
if (parent != null) {
return "<" + parent.address + " / " + parent.node + "," + address + " / " + node + ">";
} else {
return "< NULL ," + address + " / " + node + ">";
}
}
}
public LinkQualityIndicatorNetworkBrowser(ImportingQueue queue, ZigBeeNetworkManager driver) {
this.queue = queue;
this.driver = driver;
}
private NetworkAddressNodeItem getIeeeAddress(short nwkAddress) {
NetworkAddressNodeItem node = new NetworkAddressNodeItem(null, nwkAddress);
ZDO_IEEE_ADDR_RSP ieee_addr_resp = driver.sendZDOIEEEAddressRequest(
new ZDO_IEEE_ADDR_REQ(nwkAddress, ZDO_IEEE_ADDR_REQ.REQ_TYPE.SINGLE_DEVICE_RESPONSE, (byte) 0)
);
if (ieee_addr_resp == null) {
logger.debug("No ZDO_IEEE_ADDR_RSP from #{}", nwkAddress);
return null;
} else {
logger.debug(
"ZDO_IEEE_ADDR_RSP from {} with {} associated",
ieee_addr_resp.getIeeeAddress(), ieee_addr_resp.getAssociatedNodeCount()
);
node.node = new ZigBeeNodeImpl(node.address, ieee_addr_resp.getIeeeAddress(),
(short) driver.getCurrentPanId());
ZToolAddress16 nwk = new ZToolAddress16(
Integers.getByteAsInteger(node.address, 1),
Integers.getByteAsInteger(node.address, 0)
);
if (!alreadyInspected.containsKey((int) node.address)) {
queue.push(nwk, ieee_addr_resp.getIeeeAddress());
}
announceNode(node);
return node;
}
}
private void announceNodes(List<NetworkAddressNodeItem> nodes) {
if (nodes != null) {
for (int i = 0; i < nodes.size(); i++) {
announceNode(nodes.get(i));
}
}
}
private void announceNode(NetworkAddressNodeItem node) {
if (node != null) {
notifyBrowsedNode(node);
}
}
/**
* Send a Link Quality Indicator request to a neighbor of the node
* @param node The node to poll
* @param index the neighbor index (??)
* @return list of nodes found
*/
private List<NetworkAddressNodeItem> lqiRequestToNode(NetworkAddressNodeItem node, int index) {
if (alreadyInspected.get((int) node.address) == null) {
alreadyInspected.put((int) node.address, node);
// Create a list to hold the nodes we find
List<NetworkAddressNodeItem> nodesFound = new ArrayList<NetworkAddressNodeItem>();
ZToolAddress16 nwk16 = new ZToolAddress16(
Integers.getByteAsInteger(node.address, 1),
Integers.getByteAsInteger(node.address, 0)
);
logger.debug("ZDO_MGMT_LQI_REQ to {} from index {}", nwk16.get16BitValue(), index);
ZDO_MGMT_LQI_RSP lqi_resp = driver.sendLQIRequest(new ZDO_MGMT_LQI_REQ(nwk16, index));
if (lqi_resp == null) {
logger.debug("No LQI answer from #{}", nwk16.get16BitValue());
return null;
} else {
logger.debug(
"Found {} neighbors on node #{}",
lqi_resp.getNeighborLQICount(), nwk16.get16BitValue());
NeighborLqiListItemClass[] neighbors = (NeighborLqiListItemClass[]) lqi_resp.getNeighborLqiList();
if (neighbors != null) {
for (int i = 0; i < neighbors.length; i++) {
NeighborLqiListItemClass neighbor = (NeighborLqiListItemClass) neighbors[i];
logger.debug("Node #{} visible from node #{} with LQI value {}", new Object[]{neighbor.NetworkAddress.get16BitValue(), nwk16.get16BitValue(), neighbor.RxLQI});
NetworkAddressNodeItem result = getIeeeAddress((short) neighbor.NetworkAddress.get16BitValue());
NetworkAddressNodeItem newNode;
if (result != null) {
logger.debug("Node #{} is {}", new Object[]{neighbor.NetworkAddress.get16BitValue(), result.node.getIeeeAddress()});
newNode = new NetworkAddressNodeItem(node, result.address, neighbor.RxLQI);
} else {
logger.debug("No response to ZDO_IEEE_ADDR_REQ from node {}", neighbor.NetworkAddress.get16BitValue());
newNode = new NetworkAddressNodeItem(node, (short) neighbor.NetworkAddress.get16BitValue(), neighbor.RxLQI);
}
nodesFound.add(newNode);
}
}
// NeighborLQICount: neighbors IN THIS RESPONSE
// NeighborLQIEntries: all available neighbors
if (lqi_resp.getNeighborLQIEntries() > (lqi_resp.getNeighborLQICount() + index + 1)) {
logger.debug("ZDO_MGMT_LQI_REQ new request to {} because of too many entries for a single request," +
" restarting from index {}", node.address, lqi_resp.getNeighborLQICount() + index + 1);
// Poll any further neighbors, adding them to our list
List<NetworkAddressNodeItem> neighborsFound = lqiRequestToNode(node, lqi_resp.getNeighborLQICount() + index + 1);
if(neighborsFound != null) {
nodesFound.addAll(neighborsFound);
}
}
return nodesFound;
}
} else {
logger.debug("Node {} inspected few seconds ago, request delayed", node.address);
return null;
}
}
/**
* Poll all nodes in the inspection queue and announce any nodes we find to the system.
* @param toInspectTemp list of nodes to poll
*/
private void inspectQueue(ArrayList<NetworkAddressNodeItem> toInspectTemp) {
for (int i = 0; i < toInspect.size(); i++) {
List<NetworkAddressNodeItem> children;
NetworkAddressNodeItem node = toInspect.get(i);
if (node != null) {
// Request all the neighbors for this node
children = lqiRequestToNode(node, LQI_START_INDEX);
if (children != null) {
// We have neighbors - let the system know
toInspectTemp.addAll(children);
announceNodes(children);
// Keep a consolidated list of nodes and their neighbors
for(NetworkAddressNodeItem nodeItem : children) {
connectedNodeLinks.updateLQI(nodeItem.getParent(), nodeItem.getAddress(), nodeItem.getLqi());
}
}
}
}
}
public void task() {
final String threadName = Thread.currentThread().getName();
logger.trace("{} STARTED Succesfully", threadName);
while (!isDone()) {
cleanUpWalkingTree();
logger.debug("Inspecting ZigBee network for new nodes.");
try {
NetworkAddressNodeItem coordinator = getIeeeAddress(COORDINATOR_NWK_ADDRESS);
if (coordinator != null) {
//gt = new GraphThread();
// Detect all the children of the coordinator
List<NetworkAddressNodeItem> coordinatorChildren = lqiRequestToNode(coordinator, LQI_START_INDEX);
if (coordinatorChildren != null) {
// Add all children to the inspection queue
toInspect.addAll(coordinatorChildren);
// Keep a consolidated list of nodes and their neighbors
for(NetworkAddressNodeItem nodeItem : coordinatorChildren) {
connectedNodeLinks.updateLQI(nodeItem.getParent(), nodeItem.getAddress(), nodeItem.getLqi());
}
}
ArrayList<NetworkAddressNodeItem> toInspectTemp = new ArrayList<NetworkAddressNodeItem>();
while (!toInspect.isEmpty()) {
inspectQueue(toInspectTemp);
toInspect.clear();
if (!toInspectTemp.isEmpty()) {
for (int i = 0; i < toInspectTemp.size(); i++) {
toInspect.add(toInspectTemp.get(i));
}
}
toInspectTemp.clear();
}
toInspect.clear();
}
long wakeUpTime = System.currentTimeMillis() + 5 * 60 * 1000;
if (!isDone()) {
ThreadUtils.waitingUntil(wakeUpTime);
}
logger.debug("Network browsing completed, waiting until {}", wakeUpTime);
//gt.run();
} catch (Exception e) {
e.printStackTrace();
}
}
//gt.end();
logger.trace("{} TERMINATED Succesfully", threadName);
}
private void cleanUpWalkingTree() {
alreadyInspected.clear();
toInspect.clear();
}
private void notifyBrowsedNode(NetworkAddressNodeItem item) {
final ZigBeeNode child = item.node;
final ZigBeeNetwork network = ApplicationFrameworkLayer.getAFLayer(driver).getZigBeeNetwork();
network.notifyNodeBrowsed(child);
}
public NetworkNeighbourLinks getConnectedNodes() {
return connectedNodeLinks;
}
}
|
apache-2.0
|
pmarks-net/ipvfoo
|
src/common.js
|
779
|
/*
Copyright (C) 2017 Paul Marks http://www.pmarks.net/
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Flags are bitwise-OR'd across all connections to a domain.
const FLAG_SSL = 0x1;
const FLAG_NOSSL = 0x2;
const FLAG_UNCACHED = 0x4;
const FLAG_CONNECTED = 0x8;
const FLAG_WEBSOCKET = 0x10;
|
apache-2.0
|
mjem/themelog
|
themelog/themes/__init__.py
|
66
|
#!/usr/bin/env python
"""This directory holds theme modules.
"""
|
apache-2.0
|
magnayn/jLibVirt
|
src/main/java/com/nirima/libvirt/model/RemoteDomainEmulatorPinInfo.java
|
212
|
package com.nirima.libvirt.model;
import java.io.Serializable;
/**
* @author Nigel Magnay
*/
public class RemoteDomainEmulatorPinInfo implements Serializable {
public int[] cpumaps;
public int ret;
}
|
apache-2.0
|
Oceanic-815/python_training
|
test/test_phones.py
|
2326
|
import re #импортируем пакет для работы с рег. выражениями
def test_phones_on_home_page(app):
contact_from_home_page = app.contact.get_contact_list()[0] # Получаем контакт с индексом 0
contact_from_edit_page = app.contact.get_contact_info_from_edit_page(0) # получаем информацию из формы редактирования
assert contact_from_home_page.all_phones_from_home_page == merge_phones_like_on_home_page(contact_from_edit_page) # сравниваем номера между собой
assert contact_from_home_page.address == contact_from_edit_page.address
assert contact_from_home_page.allEmails_from_home_page == merge_emails_like_on_home_page(contact_from_edit_page)
def test_phones_on_contact_view_page(app):
contact_from_view_page = app.contact.get_contact_from_view_page(0) # получаем информацию со страницы просмотра контакта
contact_from_edit_page = app.contact.get_contact_info_from_edit_page(0) # получаем информацию из формы редактирования
assert contact_from_view_page.home == contact_from_edit_page.home # сравниваем номера между собой
assert contact_from_view_page.work == contact_from_edit_page.work
assert contact_from_view_page.mobile == contact_from_edit_page.mobile
assert contact_from_view_page.phone2 == contact_from_edit_page.phone2
def clear(s):
return re.sub("[() -]", "", s)# sub("что заменять", "на что заменять", где заменять)
def merge_phones_like_on_home_page(contact):
return "\n".join(filter(lambda x: x != "",
map(lambda x: clear(x),
filter(lambda x: x is not None,
[contact.home, contact.mobile, contact.work, contact.phone2]))))
# метод - слияние адресов в одну строку (техника обратных проверок)
def merge_emails_like_on_home_page(contact):
return "\n".join(filter(lambda x: x != "",
filter(lambda x: x is not None,
[contact.email, contact.email2, contact.email3])))
|
apache-2.0
|
axiros/transcrypt
|
reveal.js/js/reveal.js
|
131523
|
/*!
* reveal.js
* http://lab.hakim.se/reveal-js
* MIT licensed
*
* Copyright (C) 2016 Hakim El Hattab, http://hakim.se
*/
(function( root, factory ) {
if( typeof define === 'function' && define.amd ) {
// AMD. Register as an anonymous module.
define( function() {
root.Reveal = factory();
return root.Reveal;
} );
} else if( typeof exports === 'object' ) {
// Node. Does not work with strict CommonJS.
module.exports = factory();
} else {
// Browser globals.
root.Reveal = factory();
}
}( this, function() {
'use strict';
var Reveal;
// The reveal.js version
var VERSION = '3.3.0';
var SLIDES_SELECTOR = '.slides section',
HORIZONTAL_SLIDES_SELECTOR = '.slides>section',
VERTICAL_SLIDES_SELECTOR = '.slides>section.present>section',
HOME_SLIDE_SELECTOR = '.slides>section:first-of-type',
UA = navigator.userAgent,
// Configuration defaults, can be overridden at initialization time
config = {
// The "normal" size of the presentation, aspect ratio will be preserved
// when the presentation is scaled to fit different resolutions
width: 1280,
height: 800,
// Factor of the display size that should remain empty around the content
margin: 0.1,
// Bounds for smallest/largest possible scale to apply to content
minScale: 0.2,
maxScale: 1.5,
// Display controls in the bottom right corner
controls: true,
// Display a presentation progress bar
progress: true,
// Display the page number of the current slide
slideNumber: false,
// Push each slide change to the browser history
history: false,
// Enable keyboard shortcuts for navigation
keyboard: true,
// Optional function that blocks keyboard events when retuning false
keyboardCondition: null,
// Enable the slide overview mode
overview: true,
// Vertical centering of slides
center: true,
// Enables touch navigation on devices with touch input
touch: true,
// Loop the presentation
loop: false,
// Change the presentation direction to be RTL
rtl: false,
// Randomizes the order of slides each time the presentation loads
shuffle: false,
// Turns fragments on and off globally
fragments: true,
// Flags if the presentation is running in an embedded mode,
// i.e. contained within a limited portion of the screen
embedded: false,
// Flags if we should show a help overlay when the questionmark
// key is pressed
help: true,
// Flags if it should be possible to pause the presentation (blackout)
pause: true,
// Flags if speaker notes should be visible to all viewers
showNotes: false,
// Number of milliseconds between automatically proceeding to the
// next slide, disabled when set to 0, this value can be overwritten
// by using a data-autoslide attribute on your slides
autoSlide: 0,
// Stop auto-sliding after user input
autoSlideStoppable: true,
// Use this method for navigation when auto-sliding (defaults to navigateNext)
autoSlideMethod: null,
// Enable slide navigation via mouse wheel
mouseWheel: false,
// Apply a 3D roll to links on hover
rollingLinks: false,
// Hides the address bar on mobile devices
hideAddressBar: true,
// Opens links in an iframe preview overlay
previewLinks: false,
// Exposes the reveal.js API through window.postMessage
postMessage: true,
// Dispatches all reveal.js events to the parent window through postMessage
postMessageEvents: false,
// Focuses body when page changes visiblity to ensure keyboard shortcuts work
focusBodyOnPageVisibilityChange: true,
// Transition style
transition: 'slide', // none/fade/slide/convex/concave/zoom
// Transition speed
transitionSpeed: 'default', // default/fast/slow
// Transition style for full page slide backgrounds
backgroundTransition: 'fade', // none/fade/slide/convex/concave/zoom
// Parallax background image
parallaxBackgroundImage: '', // CSS syntax, e.g. "a.jpg"
// Parallax background size
parallaxBackgroundSize: '', // CSS syntax, e.g. "3000px 2000px"
// Amount of pixels to move the parallax background per slide step
parallaxBackgroundHorizontal: null,
parallaxBackgroundVertical: null,
// Number of slides away from the current that are visible
viewDistance: 3,
// Script dependencies to load
dependencies: []
},
// Flags if reveal.js is loaded (has dispatched the 'ready' event)
loaded = false,
// Flags if the overview mode is currently active
overview = false,
// Holds the dimensions of our overview slides, including margins
overviewSlideWidth = null,
overviewSlideHeight = null,
// The horizontal and vertical index of the currently active slide
indexh,
indexv,
// The previous and current slide HTML elements
previousSlide,
currentSlide,
previousBackground,
// Slides may hold a data-state attribute which we pick up and apply
// as a class to the body. This list contains the combined state of
// all current slides.
state = [],
// The current scale of the presentation (see width/height config)
scale = 1,
// CSS transform that is currently applied to the slides container,
// split into two groups
slidesTransform = { layout: '', overview: '' },
// Cached references to DOM elements
dom = {},
// Features supported by the browser, see #checkCapabilities()
features = {},
// Client is a mobile device, see #checkCapabilities()
isMobileDevice,
// Client is a desktop Chrome, see #checkCapabilities()
isChrome,
// Throttles mouse wheel navigation
lastMouseWheelStep = 0,
// Delays updates to the URL due to a Chrome thumbnailer bug
writeURLTimeout = 0,
// Flags if the interaction event listeners are bound
eventsAreBound = false,
// The current auto-slide duration
autoSlide = 0,
// Auto slide properties
autoSlidePlayer,
autoSlideTimeout = 0,
autoSlideStartTime = -1,
autoSlidePaused = false,
// Holds information about the currently ongoing touch input
touch = {
startX: 0,
startY: 0,
startSpan: 0,
startCount: 0,
captured: false,
threshold: 40
},
// Holds information about the keyboard shortcuts
keyboardShortcuts = {
'N , SPACE': 'Next slide',
'P': 'Previous slide',
'← , H': 'Navigate left',
'→ , L': 'Navigate right',
'↑ , K': 'Navigate up',
'↓ , J': 'Navigate down',
'Home': 'First slide',
'End': 'Last slide',
'B , .': 'Pause',
'F': 'Fullscreen',
'ESC, O': 'Slide overview'
};
/**
* Starts up the presentation if the client is capable.
*/
function initialize( options ) {
checkCapabilities();
if( !features.transforms2d && !features.transforms3d ) {
document.body.setAttribute( 'class', 'no-transforms' );
// Since JS won't be running any further, we load all lazy
// loading elements upfront
var images = toArray( document.getElementsByTagName( 'img' ) ),
iframes = toArray( document.getElementsByTagName( 'iframe' ) );
var lazyLoadable = images.concat( iframes );
for( var i = 0, len = lazyLoadable.length; i < len; i++ ) {
var element = lazyLoadable[i];
if( element.getAttribute( 'data-src' ) ) {
element.setAttribute( 'src', element.getAttribute( 'data-src' ) );
element.removeAttribute( 'data-src' );
}
}
// If the browser doesn't support core features we won't be
// using JavaScript to control the presentation
return;
}
// Cache references to key DOM elements
dom.wrapper = document.querySelector( '.reveal' );
dom.slides = document.querySelector( '.reveal .slides' );
// Force a layout when the whole page, incl fonts, has loaded
window.addEventListener( 'load', layout, false );
var query = Reveal.getQueryHash();
// Do not accept new dependencies via query config to avoid
// the potential of malicious script injection
if( typeof query['dependencies'] !== 'undefined' ) delete query['dependencies'];
// Copy options over to our config object
extend( config, options );
extend( config, query );
// Hide the address bar in mobile browsers
hideAddressBar();
// Loads the dependencies and continues to #start() once done
load();
}
/**
* Inspect the client to see what it's capable of, this
* should only happens once per runtime.
*/
function checkCapabilities() {
isMobileDevice = /(iphone|ipod|ipad|android)/gi.test( UA );
isChrome = /chrome/i.test( UA ) && !/edge/i.test( UA );
var testElement = document.createElement( 'div' );
features.transforms3d = 'WebkitPerspective' in testElement.style ||
'MozPerspective' in testElement.style ||
'msPerspective' in testElement.style ||
'OPerspective' in testElement.style ||
'perspective' in testElement.style;
features.transforms2d = 'WebkitTransform' in testElement.style ||
'MozTransform' in testElement.style ||
'msTransform' in testElement.style ||
'OTransform' in testElement.style ||
'transform' in testElement.style;
features.requestAnimationFrameMethod = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;
features.requestAnimationFrame = typeof features.requestAnimationFrameMethod === 'function';
features.canvas = !!document.createElement( 'canvas' ).getContext;
// Transitions in the overview are disabled in desktop and
// Safari due to lag
features.overviewTransitions = !/Version\/[\d\.]+.*Safari/.test( UA );
// Flags if we should use zoom instead of transform to scale
// up slides. Zoom produces crisper results but has a lot of
// xbrowser quirks so we only use it in whitelsited browsers.
features.zoom = 'zoom' in testElement.style && !isMobileDevice &&
( isChrome || /Version\/[\d\.]+.*Safari/.test( UA ) );
}
/**
* Loads the dependencies of reveal.js. Dependencies are
* defined via the configuration option 'dependencies'
* and will be loaded prior to starting/binding reveal.js.
* Some dependencies may have an 'async' flag, if so they
* will load after reveal.js has been started up.
*/
function load() {
var scripts = [],
scriptsAsync = [],
scriptsToPreload = 0;
// Called once synchronous scripts finish loading
function proceed() {
if( scriptsAsync.length ) {
// Load asynchronous scripts
head.js.apply( null, scriptsAsync );
}
start();
}
function loadScript( s ) {
head.ready( s.src.match( /([\w\d_\-]*)\.?js$|[^\\\/]*$/i )[0], function() {
// Extension may contain callback functions
if( typeof s.callback === 'function' ) {
s.callback.apply( this );
}
if( --scriptsToPreload === 0 ) {
proceed();
}
});
}
for( var i = 0, len = config.dependencies.length; i < len; i++ ) {
var s = config.dependencies[i];
// Load if there's no condition or the condition is truthy
if( !s.condition || s.condition() ) {
if( s.async ) {
scriptsAsync.push( s.src );
}
else {
scripts.push( s.src );
}
loadScript( s );
}
}
if( scripts.length ) {
scriptsToPreload = scripts.length;
// Load synchronous scripts
head.js.apply( null, scripts );
}
else {
proceed();
}
}
/**
* Starts up reveal.js by binding input events and navigating
* to the current URL deeplink if there is one.
*/
function start() {
// Make sure we've got all the DOM elements we need
setupDOM();
// Listen to messages posted to this window
setupPostMessage();
// Prevent the slides from being scrolled out of view
setupScrollPrevention();
// Resets all vertical slides so that only the first is visible
resetVerticalSlides();
// Updates the presentation to match the current configuration values
configure();
// Read the initial hash
readURL();
// Update all backgrounds
updateBackground( true );
// Notify listeners that the presentation is ready but use a 1ms
// timeout to ensure it's not fired synchronously after #initialize()
setTimeout( function() {
// Enable transitions now that we're loaded
dom.slides.classList.remove( 'no-transition' );
loaded = true;
dispatchEvent( 'ready', {
'indexh': indexh,
'indexv': indexv,
'currentSlide': currentSlide
} );
}, 1 );
// Special setup and config is required when printing to PDF
if( isPrintingPDF() ) {
removeEventListeners();
// The document needs to have loaded for the PDF layout
// measurements to be accurate
if( document.readyState === 'complete' ) {
setupPDF();
}
else {
window.addEventListener( 'load', setupPDF );
}
}
}
/**
* Finds and stores references to DOM elements which are
* required by the presentation. If a required element is
* not found, it is created.
*/
function setupDOM() {
// Prevent transitions while we're loading
dom.slides.classList.add( 'no-transition' );
// Background element
dom.background = createSingletonNode( dom.wrapper, 'div', 'backgrounds', null );
// Progress bar
dom.progress = createSingletonNode( dom.wrapper, 'div', 'progress', '<span></span>' );
dom.progressbar = dom.progress.querySelector( 'span' );
// Arrow controls
createSingletonNode( dom.wrapper, 'aside', 'controls',
'<button class="navigate-left" aria-label="previous slide"></button>' +
'<button class="navigate-right" aria-label="next slide"></button>' +
'<button class="navigate-up" aria-label="above slide"></button>' +
'<button class="navigate-down" aria-label="below slide"></button>' );
// Slide number
dom.slideNumber = createSingletonNode( dom.wrapper, 'div', 'slide-number', '' );
// Element containing notes that are visible to the audience
dom.speakerNotes = createSingletonNode( dom.wrapper, 'div', 'speaker-notes', null );
dom.speakerNotes.setAttribute( 'data-prevent-swipe', '' );
// Overlay graphic which is displayed during the paused mode
createSingletonNode( dom.wrapper, 'div', 'pause-overlay', null );
// Cache references to elements
dom.controls = document.querySelector( '.reveal .controls' );
dom.theme = document.querySelector( '#theme' );
dom.wrapper.setAttribute( 'role', 'application' );
// There can be multiple instances of controls throughout the page
dom.controlsLeft = toArray( document.querySelectorAll( '.navigate-left' ) );
dom.controlsRight = toArray( document.querySelectorAll( '.navigate-right' ) );
dom.controlsUp = toArray( document.querySelectorAll( '.navigate-up' ) );
dom.controlsDown = toArray( document.querySelectorAll( '.navigate-down' ) );
dom.controlsPrev = toArray( document.querySelectorAll( '.navigate-prev' ) );
dom.controlsNext = toArray( document.querySelectorAll( '.navigate-next' ) );
dom.statusDiv = createStatusDiv();
}
/**
* Creates a hidden div with role aria-live to announce the
* current slide content. Hide the div off-screen to make it
* available only to Assistive Technologies.
*/
function createStatusDiv() {
var statusDiv = document.getElementById( 'aria-status-div' );
if( !statusDiv ) {
statusDiv = document.createElement( 'div' );
statusDiv.style.position = 'absolute';
statusDiv.style.height = '1px';
statusDiv.style.width = '1px';
statusDiv.style.overflow ='hidden';
statusDiv.style.clip = 'rect( 1px, 1px, 1px, 1px )';
statusDiv.setAttribute( 'id', 'aria-status-div' );
statusDiv.setAttribute( 'aria-live', 'polite' );
statusDiv.setAttribute( 'aria-atomic','true' );
dom.wrapper.appendChild( statusDiv );
}
return statusDiv;
}
/**
* Configures the presentation for printing to a static
* PDF.
*/
function setupPDF() {
var slideSize = getComputedSlideSize( window.innerWidth, window.innerHeight );
// Dimensions of the PDF pages
var pageWidth = Math.floor( slideSize.width * ( 1 + config.margin ) ),
pageHeight = Math.floor( slideSize.height * ( 1 + config.margin ) );
// Dimensions of slides within the pages
var slideWidth = slideSize.width,
slideHeight = slideSize.height;
// Let the browser know what page size we want to print
injectStyleSheet( '@page{size:'+ pageWidth +'px '+ pageHeight +'px; margin: 0;}' );
// Limit the size of certain elements to the dimensions of the slide
injectStyleSheet( '.reveal section>img, .reveal section>video, .reveal section>iframe{max-width: '+ slideWidth +'px; max-height:'+ slideHeight +'px}' );
document.body.classList.add( 'print-pdf' );
document.body.style.width = pageWidth + 'px';
document.body.style.height = pageHeight + 'px';
// Add each slide's index as attributes on itself, we need these
// indices to generate slide numbers below
toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ).forEach( function( hslide, h ) {
hslide.setAttribute( 'data-index-h', h );
if( hslide.classList.contains( 'stack' ) ) {
toArray( hslide.querySelectorAll( 'section' ) ).forEach( function( vslide, v ) {
vslide.setAttribute( 'data-index-h', h );
vslide.setAttribute( 'data-index-v', v );
} );
}
} );
// Slide and slide background layout
toArray( dom.wrapper.querySelectorAll( SLIDES_SELECTOR ) ).forEach( function( slide ) {
// Vertical stacks are not centred since their section
// children will be
if( slide.classList.contains( 'stack' ) === false ) {
// Center the slide inside of the page, giving the slide some margin
var left = ( pageWidth - slideWidth ) / 2,
top = ( pageHeight - slideHeight ) / 2;
var contentHeight = getAbsoluteHeight( slide );
var numberOfPages = Math.max( Math.ceil( contentHeight / pageHeight ), 1 );
// Center slides vertically
if( numberOfPages === 1 && config.center || slide.classList.contains( 'center' ) ) {
top = Math.max( ( pageHeight - contentHeight ) / 2, 0 );
}
// Position the slide inside of the page
slide.style.left = left + 'px';
slide.style.top = top + 'px';
slide.style.width = slideWidth + 'px';
// TODO Backgrounds need to be multiplied when the slide
// stretches over multiple pages
var background = slide.querySelector( '.slide-background' );
if( background ) {
background.style.width = pageWidth + 'px';
background.style.height = ( pageHeight * numberOfPages ) + 'px';
background.style.top = -top + 'px';
background.style.left = -left + 'px';
}
// Inject notes if `showNotes` is enabled
if( config.showNotes ) {
var notes = getSlideNotes( slide );
if( notes ) {
var notesSpacing = 8;
var notesElement = document.createElement( 'div' );
notesElement.classList.add( 'speaker-notes' );
notesElement.classList.add( 'speaker-notes-pdf' );
notesElement.innerHTML = notes;
notesElement.style.left = ( notesSpacing - left ) + 'px';
notesElement.style.bottom = ( notesSpacing - top ) + 'px';
notesElement.style.width = ( pageWidth - notesSpacing*2 ) + 'px';
slide.appendChild( notesElement );
}
}
// Inject slide numbers if `slideNumbers` are enabled
if( config.slideNumber ) {
var slideNumberH = parseInt( slide.getAttribute( 'data-index-h' ), 10 ) + 1,
slideNumberV = parseInt( slide.getAttribute( 'data-index-v' ), 10 ) + 1;
var numberElement = document.createElement( 'div' );
numberElement.classList.add( 'slide-number' );
numberElement.classList.add( 'slide-number-pdf' );
numberElement.innerHTML = formatSlideNumber( slideNumberH, '.', slideNumberV );
background.appendChild( numberElement );
}
}
} );
// Show all fragments
toArray( dom.wrapper.querySelectorAll( SLIDES_SELECTOR + ' .fragment' ) ).forEach( function( fragment ) {
fragment.classList.add( 'visible' );
} );
}
/**
* This is an unfortunate necessity. Some actions – such as
* an input field being focused in an iframe or using the
* keyboard to expand text selection beyond the bounds of
* a slide – can trigger our content to be pushed out of view.
* This scrolling can not be prevented by hiding overflow in
* CSS (we already do) so we have to resort to repeatedly
* checking if the slides have been offset :(
*/
function setupScrollPrevention() {
setInterval( function() {
if( dom.wrapper.scrollTop !== 0 || dom.wrapper.scrollLeft !== 0 ) {
dom.wrapper.scrollTop = 0;
dom.wrapper.scrollLeft = 0;
}
}, 1000 );
}
/**
* Creates an HTML element and returns a reference to it.
* If the element already exists the existing instance will
* be returned.
*/
function createSingletonNode( container, tagname, classname, innerHTML ) {
// Find all nodes matching the description
var nodes = container.querySelectorAll( '.' + classname );
// Check all matches to find one which is a direct child of
// the specified container
for( var i = 0; i < nodes.length; i++ ) {
var testNode = nodes[i];
if( testNode.parentNode === container ) {
return testNode;
}
}
// If no node was found, create it now
var node = document.createElement( tagname );
node.classList.add( classname );
if( typeof innerHTML === 'string' ) {
node.innerHTML = innerHTML;
}
container.appendChild( node );
return node;
}
/**
* Creates the slide background elements and appends them
* to the background container. One element is created per
* slide no matter if the given slide has visible background.
*/
function createBackgrounds() {
var printMode = isPrintingPDF();
// Clear prior backgrounds
dom.background.innerHTML = '';
dom.background.classList.add( 'no-transition' );
// Iterate over all horizontal slides
toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ).forEach( function( slideh ) {
var backgroundStack;
if( printMode ) {
backgroundStack = createBackground( slideh, slideh );
}
else {
backgroundStack = createBackground( slideh, dom.background );
}
// Iterate over all vertical slides
toArray( slideh.querySelectorAll( 'section' ) ).forEach( function( slidev ) {
if( printMode ) {
createBackground( slidev, slidev );
}
else {
createBackground( slidev, backgroundStack );
}
backgroundStack.classList.add( 'stack' );
} );
} );
// Add parallax background if specified
if( config.parallaxBackgroundImage ) {
dom.background.style.backgroundImage = 'url("' + config.parallaxBackgroundImage + '")';
dom.background.style.backgroundSize = config.parallaxBackgroundSize;
// Make sure the below properties are set on the element - these properties are
// needed for proper transitions to be set on the element via CSS. To remove
// annoying background slide-in effect when the presentation starts, apply
// these properties after short time delay
setTimeout( function() {
dom.wrapper.classList.add( 'has-parallax-background' );
}, 1 );
}
else {
dom.background.style.backgroundImage = '';
dom.wrapper.classList.remove( 'has-parallax-background' );
}
}
/**
* Creates a background for the given slide.
*
* @param {HTMLElement} slide
* @param {HTMLElement} container The element that the background
* should be appended to
*/
function createBackground( slide, container ) {
var data = {
background: slide.getAttribute( 'data-background' ),
backgroundSize: slide.getAttribute( 'data-background-size' ),
backgroundImage: slide.getAttribute( 'data-background-image' ),
backgroundVideo: slide.getAttribute( 'data-background-video' ),
backgroundIframe: slide.getAttribute( 'data-background-iframe' ),
backgroundColor: slide.getAttribute( 'data-background-color' ),
backgroundRepeat: slide.getAttribute( 'data-background-repeat' ),
backgroundPosition: slide.getAttribute( 'data-background-position' ),
backgroundTransition: slide.getAttribute( 'data-background-transition' )
};
var element = document.createElement( 'div' );
// Carry over custom classes from the slide to the background
element.className = 'slide-background ' + slide.className.replace( /present|past|future/, '' );
if( data.background ) {
// Auto-wrap image urls in url(...)
if( /^(http|file|\/\/)/gi.test( data.background ) || /\.(svg|png|jpg|jpeg|gif|bmp)$/gi.test( data.background ) ) {
slide.setAttribute( 'data-background-image', data.background );
}
else {
element.style.background = data.background;
}
}
// Create a hash for this combination of background settings.
// This is used to determine when two slide backgrounds are
// the same.
if( data.background || data.backgroundColor || data.backgroundImage || data.backgroundVideo || data.backgroundIframe ) {
element.setAttribute( 'data-background-hash', data.background +
data.backgroundSize +
data.backgroundImage +
data.backgroundVideo +
data.backgroundIframe +
data.backgroundColor +
data.backgroundRepeat +
data.backgroundPosition +
data.backgroundTransition );
}
// Additional and optional background properties
if( data.backgroundSize ) element.style.backgroundSize = data.backgroundSize;
if( data.backgroundColor ) element.style.backgroundColor = data.backgroundColor;
if( data.backgroundRepeat ) element.style.backgroundRepeat = data.backgroundRepeat;
if( data.backgroundPosition ) element.style.backgroundPosition = data.backgroundPosition;
if( data.backgroundTransition ) element.setAttribute( 'data-background-transition', data.backgroundTransition );
container.appendChild( element );
// If backgrounds are being recreated, clear old classes
slide.classList.remove( 'has-dark-background' );
slide.classList.remove( 'has-light-background' );
// If this slide has a background color, add a class that
// signals if it is light or dark. If the slide has no background
// color, no class will be set
var computedBackgroundColor = window.getComputedStyle( element ).backgroundColor;
if( computedBackgroundColor ) {
var rgb = colorToRgb( computedBackgroundColor );
// Ignore fully transparent backgrounds. Some browsers return
// rgba(0,0,0,0) when reading the computed background color of
// an element with no background
if( rgb && rgb.a !== 0 ) {
if( colorBrightness( computedBackgroundColor ) < 128 ) {
slide.classList.add( 'has-dark-background' );
}
else {
slide.classList.add( 'has-light-background' );
}
}
}
return element;
}
/**
* Registers a listener to postMessage events, this makes it
* possible to call all reveal.js API methods from another
* window. For example:
*
* revealWindow.postMessage( JSON.stringify({
* method: 'slide',
* args: [ 2 ]
* }), '*' );
*/
function setupPostMessage() {
if( config.postMessage ) {
window.addEventListener( 'message', function ( event ) {
var data = event.data;
// Make sure we're dealing with JSON
if( typeof data === 'string' && data.charAt( 0 ) === '{' && data.charAt( data.length - 1 ) === '}' ) {
data = JSON.parse( data );
// Check if the requested method can be found
if( data.method && typeof Reveal[data.method] === 'function' ) {
Reveal[data.method].apply( Reveal, data.args );
}
}
}, false );
}
}
/**
* Applies the configuration settings from the config
* object. May be called multiple times.
*/
function configure( options ) {
var numberOfSlides = dom.wrapper.querySelectorAll( SLIDES_SELECTOR ).length;
dom.wrapper.classList.remove( config.transition );
// New config options may be passed when this method
// is invoked through the API after initialization
if( typeof options === 'object' ) extend( config, options );
// Force linear transition based on browser capabilities
if( features.transforms3d === false ) config.transition = 'linear';
dom.wrapper.classList.add( config.transition );
dom.wrapper.setAttribute( 'data-transition-speed', config.transitionSpeed );
dom.wrapper.setAttribute( 'data-background-transition', config.backgroundTransition );
dom.controls.style.display = config.controls ? 'block' : 'none';
dom.progress.style.display = config.progress ? 'block' : 'none';
dom.slideNumber.style.display = config.slideNumber && !isPrintingPDF() ? 'block' : 'none';
if( config.shuffle ) {
shuffle();
}
if( config.rtl ) {
dom.wrapper.classList.add( 'rtl' );
}
else {
dom.wrapper.classList.remove( 'rtl' );
}
if( config.center ) {
dom.wrapper.classList.add( 'center' );
}
else {
dom.wrapper.classList.remove( 'center' );
}
// Exit the paused mode if it was configured off
if( config.pause === false ) {
resume();
}
if( config.showNotes ) {
dom.speakerNotes.classList.add( 'visible' );
}
else {
dom.speakerNotes.classList.remove( 'visible' );
}
if( config.mouseWheel ) {
document.addEventListener( 'DOMMouseScroll', onDocumentMouseScroll, false ); // FF
document.addEventListener( 'mousewheel', onDocumentMouseScroll, false );
}
else {
document.removeEventListener( 'DOMMouseScroll', onDocumentMouseScroll, false ); // FF
document.removeEventListener( 'mousewheel', onDocumentMouseScroll, false );
}
// Rolling 3D links
if( config.rollingLinks ) {
enableRollingLinks();
}
else {
disableRollingLinks();
}
// Iframe link previews
if( config.previewLinks ) {
enablePreviewLinks();
}
else {
disablePreviewLinks();
enablePreviewLinks( '[data-preview-link]' );
}
// Remove existing auto-slide controls
if( autoSlidePlayer ) {
autoSlidePlayer.destroy();
autoSlidePlayer = null;
}
// Generate auto-slide controls if needed
if( numberOfSlides > 1 && config.autoSlide && config.autoSlideStoppable && features.canvas && features.requestAnimationFrame ) {
autoSlidePlayer = new Playback( dom.wrapper, function() {
return Math.min( Math.max( ( Date.now() - autoSlideStartTime ) / autoSlide, 0 ), 1 );
} );
autoSlidePlayer.on( 'click', onAutoSlidePlayerClick );
autoSlidePaused = false;
}
// When fragments are turned off they should be visible
if( config.fragments === false ) {
toArray( dom.slides.querySelectorAll( '.fragment' ) ).forEach( function( element ) {
element.classList.add( 'visible' );
element.classList.remove( 'current-fragment' );
} );
}
sync();
}
/**
* Binds all event listeners.
*/
function addEventListeners() {
eventsAreBound = true;
window.addEventListener( 'hashchange', onWindowHashChange, false );
window.addEventListener( 'resize', onWindowResize, false );
if( config.touch ) {
dom.wrapper.addEventListener( 'touchstart', onTouchStart, false );
dom.wrapper.addEventListener( 'touchmove', onTouchMove, false );
dom.wrapper.addEventListener( 'touchend', onTouchEnd, false );
// Support pointer-style touch interaction as well
if( window.navigator.pointerEnabled ) {
// IE 11 uses un-prefixed version of pointer events
dom.wrapper.addEventListener( 'pointerdown', onPointerDown, false );
dom.wrapper.addEventListener( 'pointermove', onPointerMove, false );
dom.wrapper.addEventListener( 'pointerup', onPointerUp, false );
}
else if( window.navigator.msPointerEnabled ) {
// IE 10 uses prefixed version of pointer events
dom.wrapper.addEventListener( 'MSPointerDown', onPointerDown, false );
dom.wrapper.addEventListener( 'MSPointerMove', onPointerMove, false );
dom.wrapper.addEventListener( 'MSPointerUp', onPointerUp, false );
}
}
if( config.keyboard ) {
document.addEventListener( 'keydown', onDocumentKeyDown, false );
document.addEventListener( 'keypress', onDocumentKeyPress, false );
}
if( config.progress && dom.progress ) {
dom.progress.addEventListener( 'click', onProgressClicked, false );
}
if( config.focusBodyOnPageVisibilityChange ) {
var visibilityChange;
if( 'hidden' in document ) {
visibilityChange = 'visibilitychange';
}
else if( 'msHidden' in document ) {
visibilityChange = 'msvisibilitychange';
}
else if( 'webkitHidden' in document ) {
visibilityChange = 'webkitvisibilitychange';
}
if( visibilityChange ) {
document.addEventListener( visibilityChange, onPageVisibilityChange, false );
}
}
// Listen to both touch and click events, in case the device
// supports both
var pointerEvents = [ 'touchstart', 'click' ];
// Only support touch for Android, fixes double navigations in
// stock browser
if( UA.match( /android/gi ) ) {
pointerEvents = [ 'touchstart' ];
}
pointerEvents.forEach( function( eventName ) {
dom.controlsLeft.forEach( function( el ) { el.addEventListener( eventName, onNavigateLeftClicked, false ); } );
dom.controlsRight.forEach( function( el ) { el.addEventListener( eventName, onNavigateRightClicked, false ); } );
dom.controlsUp.forEach( function( el ) { el.addEventListener( eventName, onNavigateUpClicked, false ); } );
dom.controlsDown.forEach( function( el ) { el.addEventListener( eventName, onNavigateDownClicked, false ); } );
dom.controlsPrev.forEach( function( el ) { el.addEventListener( eventName, onNavigatePrevClicked, false ); } );
dom.controlsNext.forEach( function( el ) { el.addEventListener( eventName, onNavigateNextClicked, false ); } );
} );
}
/**
* Unbinds all event listeners.
*/
function removeEventListeners() {
eventsAreBound = false;
document.removeEventListener( 'keydown', onDocumentKeyDown, false );
document.removeEventListener( 'keypress', onDocumentKeyPress, false );
window.removeEventListener( 'hashchange', onWindowHashChange, false );
window.removeEventListener( 'resize', onWindowResize, false );
dom.wrapper.removeEventListener( 'touchstart', onTouchStart, false );
dom.wrapper.removeEventListener( 'touchmove', onTouchMove, false );
dom.wrapper.removeEventListener( 'touchend', onTouchEnd, false );
// IE11
if( window.navigator.pointerEnabled ) {
dom.wrapper.removeEventListener( 'pointerdown', onPointerDown, false );
dom.wrapper.removeEventListener( 'pointermove', onPointerMove, false );
dom.wrapper.removeEventListener( 'pointerup', onPointerUp, false );
}
// IE10
else if( window.navigator.msPointerEnabled ) {
dom.wrapper.removeEventListener( 'MSPointerDown', onPointerDown, false );
dom.wrapper.removeEventListener( 'MSPointerMove', onPointerMove, false );
dom.wrapper.removeEventListener( 'MSPointerUp', onPointerUp, false );
}
if ( config.progress && dom.progress ) {
dom.progress.removeEventListener( 'click', onProgressClicked, false );
}
[ 'touchstart', 'click' ].forEach( function( eventName ) {
dom.controlsLeft.forEach( function( el ) { el.removeEventListener( eventName, onNavigateLeftClicked, false ); } );
dom.controlsRight.forEach( function( el ) { el.removeEventListener( eventName, onNavigateRightClicked, false ); } );
dom.controlsUp.forEach( function( el ) { el.removeEventListener( eventName, onNavigateUpClicked, false ); } );
dom.controlsDown.forEach( function( el ) { el.removeEventListener( eventName, onNavigateDownClicked, false ); } );
dom.controlsPrev.forEach( function( el ) { el.removeEventListener( eventName, onNavigatePrevClicked, false ); } );
dom.controlsNext.forEach( function( el ) { el.removeEventListener( eventName, onNavigateNextClicked, false ); } );
} );
}
/**
* Extend object a with the properties of object b.
* If there's a conflict, object b takes precedence.
*/
function extend( a, b ) {
for( var i in b ) {
a[ i ] = b[ i ];
}
}
/**
* Converts the target object to an array.
*/
function toArray( o ) {
return Array.prototype.slice.call( o );
}
/**
* Utility for deserializing a value.
*/
function deserialize( value ) {
if( typeof value === 'string' ) {
if( value === 'null' ) return null;
else if( value === 'true' ) return true;
else if( value === 'false' ) return false;
else if( value.match( /^\d+$/ ) ) return parseFloat( value );
}
return value;
}
/**
* Measures the distance in pixels between point a
* and point b.
*
* @param {Object} a point with x/y properties
* @param {Object} b point with x/y properties
*/
function distanceBetween( a, b ) {
var dx = a.x - b.x,
dy = a.y - b.y;
return Math.sqrt( dx*dx + dy*dy );
}
/**
* Applies a CSS transform to the target element.
*/
function transformElement( element, transform ) {
element.style.WebkitTransform = transform;
element.style.MozTransform = transform;
element.style.msTransform = transform;
element.style.transform = transform;
}
/**
* Applies CSS transforms to the slides container. The container
* is transformed from two separate sources: layout and the overview
* mode.
*/
function transformSlides( transforms ) {
// Pick up new transforms from arguments
if( typeof transforms.layout === 'string' ) slidesTransform.layout = transforms.layout;
if( typeof transforms.overview === 'string' ) slidesTransform.overview = transforms.overview;
// Apply the transforms to the slides container
if( slidesTransform.layout ) {
transformElement( dom.slides, slidesTransform.layout + ' ' + slidesTransform.overview );
}
else {
transformElement( dom.slides, slidesTransform.overview );
}
}
/**
* Injects the given CSS styles into the DOM.
*/
function injectStyleSheet( value ) {
var tag = document.createElement( 'style' );
tag.type = 'text/css';
if( tag.styleSheet ) {
tag.styleSheet.cssText = value;
}
else {
tag.appendChild( document.createTextNode( value ) );
}
document.getElementsByTagName( 'head' )[0].appendChild( tag );
}
/**
* Converts various color input formats to an {r:0,g:0,b:0} object.
*
* @param {String} color The string representation of a color,
* the following formats are supported:
* - #000
* - #000000
* - rgb(0,0,0)
*/
function colorToRgb( color ) {
var hex3 = color.match( /^#([0-9a-f]{3})$/i );
if( hex3 && hex3[1] ) {
hex3 = hex3[1];
return {
r: parseInt( hex3.charAt( 0 ), 16 ) * 0x11,
g: parseInt( hex3.charAt( 1 ), 16 ) * 0x11,
b: parseInt( hex3.charAt( 2 ), 16 ) * 0x11
};
}
var hex6 = color.match( /^#([0-9a-f]{6})$/i );
if( hex6 && hex6[1] ) {
hex6 = hex6[1];
return {
r: parseInt( hex6.substr( 0, 2 ), 16 ),
g: parseInt( hex6.substr( 2, 2 ), 16 ),
b: parseInt( hex6.substr( 4, 2 ), 16 )
};
}
var rgb = color.match( /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i );
if( rgb ) {
return {
r: parseInt( rgb[1], 10 ),
g: parseInt( rgb[2], 10 ),
b: parseInt( rgb[3], 10 )
};
}
var rgba = color.match( /^rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\,\s*([\d]+|[\d]*.[\d]+)\s*\)$/i );
if( rgba ) {
return {
r: parseInt( rgba[1], 10 ),
g: parseInt( rgba[2], 10 ),
b: parseInt( rgba[3], 10 ),
a: parseFloat( rgba[4] )
};
}
return null;
}
/**
* Calculates brightness on a scale of 0-255.
*
* @param color See colorStringToRgb for supported formats.
*/
function colorBrightness( color ) {
if( typeof color === 'string' ) color = colorToRgb( color );
if( color ) {
return ( color.r * 299 + color.g * 587 + color.b * 114 ) / 1000;
}
return null;
}
/**
* Retrieves the height of the given element by looking
* at the position and height of its immediate children.
*/
function getAbsoluteHeight( element ) {
var height = 0;
if( element ) {
var absoluteChildren = 0;
toArray( element.childNodes ).forEach( function( child ) {
if( typeof child.offsetTop === 'number' && child.style ) {
// Count # of abs children
if( window.getComputedStyle( child ).position === 'absolute' ) {
absoluteChildren += 1;
}
height = Math.max( height, child.offsetTop + child.offsetHeight );
}
} );
// If there are no absolute children, use offsetHeight
if( absoluteChildren === 0 ) {
height = element.offsetHeight;
}
}
return height;
}
/**
* Returns the remaining height within the parent of the
* target element.
*
* remaining height = [ configured parent height ] - [ current parent height ]
*/
function getRemainingHeight( element, height ) {
height = height || 0;
if( element ) {
var newHeight, oldHeight = element.style.height;
// Change the .stretch element height to 0 in order find the height of all
// the other elements
element.style.height = '0px';
newHeight = height - element.parentNode.offsetHeight;
// Restore the old height, just in case
element.style.height = oldHeight + 'px';
return newHeight;
}
return height;
}
/**
* Checks if this instance is being used to print a PDF.
*/
function isPrintingPDF() {
return ( /print-pdf/gi ).test( window.location.search );
}
/**
* Hides the address bar if we're on a mobile device.
*/
function hideAddressBar() {
if( config.hideAddressBar && isMobileDevice ) {
// Events that should trigger the address bar to hide
window.addEventListener( 'load', removeAddressBar, false );
window.addEventListener( 'orientationchange', removeAddressBar, false );
}
}
/**
* Causes the address bar to hide on mobile devices,
* more vertical space ftw.
*/
function removeAddressBar() {
setTimeout( function() {
window.scrollTo( 0, 1 );
}, 10 );
}
/**
* Dispatches an event of the specified type from the
* reveal DOM element.
*/
function dispatchEvent( type, args ) {
var event = document.createEvent( 'HTMLEvents', 1, 2 );
event.initEvent( type, true, true );
extend( event, args );
dom.wrapper.dispatchEvent( event );
// If we're in an iframe, post each reveal.js event to the
// parent window. Used by the notes plugin
if( config.postMessageEvents && window.parent !== window.self ) {
window.parent.postMessage( JSON.stringify({ namespace: 'reveal', eventName: type, state: getState() }), '*' );
}
}
/**
* Wrap all links in 3D goodness.
*/
function enableRollingLinks() {
if( features.transforms3d && !( 'msPerspective' in document.body.style ) ) {
var anchors = dom.wrapper.querySelectorAll( SLIDES_SELECTOR + ' a' );
for( var i = 0, len = anchors.length; i < len; i++ ) {
var anchor = anchors[i];
if( anchor.textContent && !anchor.querySelector( '*' ) && ( !anchor.className || !anchor.classList.contains( anchor, 'roll' ) ) ) {
var span = document.createElement('span');
span.setAttribute('data-title', anchor.text);
span.innerHTML = anchor.innerHTML;
anchor.classList.add( 'roll' );
anchor.innerHTML = '';
anchor.appendChild(span);
}
}
}
}
/**
* Unwrap all 3D links.
*/
function disableRollingLinks() {
var anchors = dom.wrapper.querySelectorAll( SLIDES_SELECTOR + ' a.roll' );
for( var i = 0, len = anchors.length; i < len; i++ ) {
var anchor = anchors[i];
var span = anchor.querySelector( 'span' );
if( span ) {
anchor.classList.remove( 'roll' );
anchor.innerHTML = span.innerHTML;
}
}
}
/**
* Bind preview frame links.
*/
function enablePreviewLinks( selector ) {
var anchors = toArray( document.querySelectorAll( selector ? selector : 'a' ) );
anchors.forEach( function( element ) {
if( /^(http|www)/gi.test( element.getAttribute( 'href' ) ) ) {
element.addEventListener( 'click', onPreviewLinkClicked, false );
}
} );
}
/**
* Unbind preview frame links.
*/
function disablePreviewLinks() {
var anchors = toArray( document.querySelectorAll( 'a' ) );
anchors.forEach( function( element ) {
if( /^(http|www)/gi.test( element.getAttribute( 'href' ) ) ) {
element.removeEventListener( 'click', onPreviewLinkClicked, false );
}
} );
}
/**
* Opens a preview window for the target URL.
*/
function showPreview( url ) {
closeOverlay();
dom.overlay = document.createElement( 'div' );
dom.overlay.classList.add( 'overlay' );
dom.overlay.classList.add( 'overlay-preview' );
dom.wrapper.appendChild( dom.overlay );
dom.overlay.innerHTML = [
'<header>',
'<a class="close" href="#"><span class="icon"></span></a>',
'<a class="external" href="'+ url +'" target="_blank"><span class="icon"></span></a>',
'</header>',
'<div class="spinner"></div>',
'<div class="viewport">',
'<iframe src="'+ url +'"></iframe>',
'</div>'
].join('');
dom.overlay.querySelector( 'iframe' ).addEventListener( 'load', function( event ) {
dom.overlay.classList.add( 'loaded' );
}, false );
dom.overlay.querySelector( '.close' ).addEventListener( 'click', function( event ) {
closeOverlay();
event.preventDefault();
}, false );
dom.overlay.querySelector( '.external' ).addEventListener( 'click', function( event ) {
closeOverlay();
}, false );
setTimeout( function() {
dom.overlay.classList.add( 'visible' );
}, 1 );
}
/**
* Opens a overlay window with help material.
*/
function showHelp() {
if( config.help ) {
closeOverlay();
dom.overlay = document.createElement( 'div' );
dom.overlay.classList.add( 'overlay' );
dom.overlay.classList.add( 'overlay-help' );
dom.wrapper.appendChild( dom.overlay );
var html = '<p class="title">Keyboard Shortcuts</p><br/>';
html += '<table><th>KEY</th><th>ACTION</th>';
for( var key in keyboardShortcuts ) {
html += '<tr><td>' + key + '</td><td>' + keyboardShortcuts[ key ] + '</td></tr>';
}
html += '</table>';
dom.overlay.innerHTML = [
'<header>',
'<a class="close" href="#"><span class="icon"></span></a>',
'</header>',
'<div class="viewport">',
'<div class="viewport-inner">'+ html +'</div>',
'</div>'
].join('');
dom.overlay.querySelector( '.close' ).addEventListener( 'click', function( event ) {
closeOverlay();
event.preventDefault();
}, false );
setTimeout( function() {
dom.overlay.classList.add( 'visible' );
}, 1 );
}
}
/**
* Closes any currently open overlay.
*/
function closeOverlay() {
if( dom.overlay ) {
dom.overlay.parentNode.removeChild( dom.overlay );
dom.overlay = null;
}
}
/**
* Applies JavaScript-controlled layout rules to the
* presentation.
*/
function layout() {
if( dom.wrapper && !isPrintingPDF() ) {
var size = getComputedSlideSize();
var slidePadding = 20; // TODO Dig this out of DOM
// Layout the contents of the slides
layoutSlideContents( config.width, config.height, slidePadding );
dom.slides.style.width = size.width + 'px';
dom.slides.style.height = size.height + 'px';
// Determine scale of content to fit within available space
scale = Math.min( size.presentationWidth / size.width, size.presentationHeight / size.height );
// Respect max/min scale settings
scale = Math.max( scale, config.minScale );
scale = Math.min( scale, config.maxScale );
// Don't apply any scaling styles if scale is 1
if( scale === 1 ) {
dom.slides.style.zoom = '';
dom.slides.style.left = '';
dom.slides.style.top = '';
dom.slides.style.bottom = '';
dom.slides.style.right = '';
transformSlides( { layout: '' } );
}
else {
// Prefer zoom for scaling up so that content remains crisp.
// Don't use zoom to scale down since that can lead to shifts
// in text layout/line breaks.
if( scale > 1 && features.zoom ) {
dom.slides.style.zoom = scale;
dom.slides.style.left = '';
dom.slides.style.top = '';
dom.slides.style.bottom = '';
dom.slides.style.right = '';
transformSlides( { layout: '' } );
}
// Apply scale transform as a fallback
else {
dom.slides.style.zoom = '';
dom.slides.style.left = '50%';
dom.slides.style.top = '50%';
dom.slides.style.bottom = 'auto';
dom.slides.style.right = 'auto';
transformSlides( { layout: 'translate(-50%, -50%) scale('+ scale +')' } );
}
}
// Select all slides, vertical and horizontal
var slides = toArray( dom.wrapper.querySelectorAll( SLIDES_SELECTOR ) );
for( var i = 0, len = slides.length; i < len; i++ ) {
var slide = slides[ i ];
// Don't bother updating invisible slides
if( slide.style.display === 'none' ) {
continue;
}
if( config.center || slide.classList.contains( 'center' ) ) {
// Vertical stacks are not centred since their section
// children will be
if( slide.classList.contains( 'stack' ) ) {
slide.style.top = 0;
}
else {
slide.style.top = Math.max( ( ( size.height - getAbsoluteHeight( slide ) ) / 2 ) - slidePadding, 0 ) + 'px';
}
}
else {
slide.style.top = '';
}
}
updateProgress();
updateParallax();
}
}
/**
* Applies layout logic to the contents of all slides in
* the presentation.
*/
function layoutSlideContents( width, height, padding ) {
// Handle sizing of elements with the 'stretch' class
toArray( dom.slides.querySelectorAll( 'section > .stretch' ) ).forEach( function( element ) {
// Determine how much vertical space we can use
var remainingHeight = getRemainingHeight( element, height );
// Consider the aspect ratio of media elements
if( /(img|video)/gi.test( element.nodeName ) ) {
var nw = element.naturalWidth || element.videoWidth,
nh = element.naturalHeight || element.videoHeight;
var es = Math.min( width / nw, remainingHeight / nh );
element.style.width = ( nw * es ) + 'px';
element.style.height = ( nh * es ) + 'px';
}
else {
element.style.width = width + 'px';
element.style.height = remainingHeight + 'px';
}
} );
}
/**
* Calculates the computed pixel size of our slides. These
* values are based on the width and height configuration
* options.
*/
function getComputedSlideSize( presentationWidth, presentationHeight ) {
var size = {
// Slide size
width: config.width,
height: config.height,
// Presentation size
presentationWidth: presentationWidth || dom.wrapper.offsetWidth,
presentationHeight: presentationHeight || dom.wrapper.offsetHeight
};
// Reduce available space by margin
size.presentationWidth -= ( size.presentationWidth * config.margin );
size.presentationHeight -= ( size.presentationHeight * config.margin );
// Slide width may be a percentage of available width
if( typeof size.width === 'string' && /%$/.test( size.width ) ) {
size.width = parseInt( size.width, 10 ) / 100 * size.presentationWidth;
}
// Slide height may be a percentage of available height
if( typeof size.height === 'string' && /%$/.test( size.height ) ) {
size.height = parseInt( size.height, 10 ) / 100 * size.presentationHeight;
}
return size;
}
/**
* Stores the vertical index of a stack so that the same
* vertical slide can be selected when navigating to and
* from the stack.
*
* @param {HTMLElement} stack The vertical stack element
* @param {int} v Index to memorize
*/
function setPreviousVerticalIndex( stack, v ) {
if( typeof stack === 'object' && typeof stack.setAttribute === 'function' ) {
stack.setAttribute( 'data-previous-indexv', v || 0 );
}
}
/**
* Retrieves the vertical index which was stored using
* #setPreviousVerticalIndex() or 0 if no previous index
* exists.
*
* @param {HTMLElement} stack The vertical stack element
*/
function getPreviousVerticalIndex( stack ) {
if( typeof stack === 'object' && typeof stack.setAttribute === 'function' && stack.classList.contains( 'stack' ) ) {
// Prefer manually defined start-indexv
var attributeName = stack.hasAttribute( 'data-start-indexv' ) ? 'data-start-indexv' : 'data-previous-indexv';
return parseInt( stack.getAttribute( attributeName ) || 0, 10 );
}
return 0;
}
/**
* Displays the overview of slides (quick nav) by scaling
* down and arranging all slide elements.
*/
function activateOverview() {
// Only proceed if enabled in config
if( config.overview && !isOverview() ) {
overview = true;
dom.wrapper.classList.add( 'overview' );
dom.wrapper.classList.remove( 'overview-deactivating' );
if( features.overviewTransitions ) {
setTimeout( function() {
dom.wrapper.classList.add( 'overview-animated' );
}, 1 );
}
// Don't auto-slide while in overview mode
cancelAutoSlide();
// Move the backgrounds element into the slide container to
// that the same scaling is applied
dom.slides.appendChild( dom.background );
// Clicking on an overview slide navigates to it
toArray( dom.wrapper.querySelectorAll( SLIDES_SELECTOR ) ).forEach( function( slide ) {
if( !slide.classList.contains( 'stack' ) ) {
slide.addEventListener( 'click', onOverviewSlideClicked, true );
}
} );
// Calculate slide sizes
var margin = 70;
var slideSize = getComputedSlideSize();
overviewSlideWidth = slideSize.width + margin;
overviewSlideHeight = slideSize.height + margin;
// Reverse in RTL mode
if( config.rtl ) {
overviewSlideWidth = -overviewSlideWidth;
}
updateSlidesVisibility();
layoutOverview();
updateOverview();
layout();
// Notify observers of the overview showing
dispatchEvent( 'overviewshown', {
'indexh': indexh,
'indexv': indexv,
'currentSlide': currentSlide
} );
}
}
/**
* Uses CSS transforms to position all slides in a grid for
* display inside of the overview mode.
*/
function layoutOverview() {
// Layout slides
toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ).forEach( function( hslide, h ) {
hslide.setAttribute( 'data-index-h', h );
transformElement( hslide, 'translate3d(' + ( h * overviewSlideWidth ) + 'px, 0, 0)' );
if( hslide.classList.contains( 'stack' ) ) {
toArray( hslide.querySelectorAll( 'section' ) ).forEach( function( vslide, v ) {
vslide.setAttribute( 'data-index-h', h );
vslide.setAttribute( 'data-index-v', v );
transformElement( vslide, 'translate3d(0, ' + ( v * overviewSlideHeight ) + 'px, 0)' );
} );
}
} );
// Layout slide backgrounds
toArray( dom.background.childNodes ).forEach( function( hbackground, h ) {
transformElement( hbackground, 'translate3d(' + ( h * overviewSlideWidth ) + 'px, 0, 0)' );
toArray( hbackground.querySelectorAll( '.slide-background' ) ).forEach( function( vbackground, v ) {
transformElement( vbackground, 'translate3d(0, ' + ( v * overviewSlideHeight ) + 'px, 0)' );
} );
} );
}
/**
* Moves the overview viewport to the current slides.
* Called each time the current slide changes.
*/
function updateOverview() {
transformSlides( {
overview: [
'translateX('+ ( -indexh * overviewSlideWidth ) +'px)',
'translateY('+ ( -indexv * overviewSlideHeight ) +'px)',
'translateZ('+ ( window.innerWidth < 400 ? -1000 : -2500 ) +'px)'
].join( ' ' )
} );
}
/**
* Exits the slide overview and enters the currently
* active slide.
*/
function deactivateOverview() {
// Only proceed if enabled in config
if( config.overview ) {
overview = false;
dom.wrapper.classList.remove( 'overview' );
dom.wrapper.classList.remove( 'overview-animated' );
// Temporarily add a class so that transitions can do different things
// depending on whether they are exiting/entering overview, or just
// moving from slide to slide
dom.wrapper.classList.add( 'overview-deactivating' );
setTimeout( function () {
dom.wrapper.classList.remove( 'overview-deactivating' );
}, 1 );
// Move the background element back out
dom.wrapper.appendChild( dom.background );
// Clean up changes made to slides
toArray( dom.wrapper.querySelectorAll( SLIDES_SELECTOR ) ).forEach( function( slide ) {
transformElement( slide, '' );
slide.removeEventListener( 'click', onOverviewSlideClicked, true );
} );
// Clean up changes made to backgrounds
toArray( dom.background.querySelectorAll( '.slide-background' ) ).forEach( function( background ) {
transformElement( background, '' );
} );
transformSlides( { overview: '' } );
slide( indexh, indexv );
layout();
cueAutoSlide();
// Notify observers of the overview hiding
dispatchEvent( 'overviewhidden', {
'indexh': indexh,
'indexv': indexv,
'currentSlide': currentSlide
} );
}
}
/**
* Toggles the slide overview mode on and off.
*
* @param {Boolean} override Optional flag which overrides the
* toggle logic and forcibly sets the desired state. True means
* overview is open, false means it's closed.
*/
function toggleOverview( override ) {
if( typeof override === 'boolean' ) {
override ? activateOverview() : deactivateOverview();
}
else {
isOverview() ? deactivateOverview() : activateOverview();
}
}
/**
* Checks if the overview is currently active.
*
* @return {Boolean} true if the overview is active,
* false otherwise
*/
function isOverview() {
return overview;
}
/**
* Checks if the current or specified slide is vertical
* (nested within another slide).
*
* @param {HTMLElement} slide [optional] The slide to check
* orientation of
*/
function isVerticalSlide( slide ) {
// Prefer slide argument, otherwise use current slide
slide = slide ? slide : currentSlide;
return slide && slide.parentNode && !!slide.parentNode.nodeName.match( /section/i );
}
/**
* Handling the fullscreen functionality via the fullscreen API
*
* @see http://fullscreen.spec.whatwg.org/
* @see https://developer.mozilla.org/en-US/docs/DOM/Using_fullscreen_mode
*/
function enterFullscreen() {
var element = document.documentElement;
// Check which implementation is available
var requestMethod = element.requestFullscreen ||
element.webkitRequestFullscreen ||
element.webkitRequestFullScreen ||
element.mozRequestFullScreen ||
element.msRequestFullscreen;
if( requestMethod ) {
requestMethod.apply( element );
}
}
/**
* Enters the paused mode which fades everything on screen to
* black.
*/
function pause() {
if( config.pause ) {
var wasPaused = dom.wrapper.classList.contains( 'paused' );
cancelAutoSlide();
dom.wrapper.classList.add( 'paused' );
if( wasPaused === false ) {
dispatchEvent( 'paused' );
}
}
}
/**
* Exits from the paused mode.
*/
function resume() {
var wasPaused = dom.wrapper.classList.contains( 'paused' );
dom.wrapper.classList.remove( 'paused' );
cueAutoSlide();
if( wasPaused ) {
dispatchEvent( 'resumed' );
}
}
/**
* Toggles the paused mode on and off.
*/
function togglePause( override ) {
if( typeof override === 'boolean' ) {
override ? pause() : resume();
}
else {
isPaused() ? resume() : pause();
}
}
/**
* Checks if we are currently in the paused mode.
*/
function isPaused() {
return dom.wrapper.classList.contains( 'paused' );
}
/**
* Toggles the auto slide mode on and off.
*
* @param {Boolean} override Optional flag which sets the desired state.
* True means autoplay starts, false means it stops.
*/
function toggleAutoSlide( override ) {
if( typeof override === 'boolean' ) {
override ? resumeAutoSlide() : pauseAutoSlide();
}
else {
autoSlidePaused ? resumeAutoSlide() : pauseAutoSlide();
}
}
/**
* Checks if the auto slide mode is currently on.
*/
function isAutoSliding() {
return !!( autoSlide && !autoSlidePaused );
}
/**
* Steps from the current point in the presentation to the
* slide which matches the specified horizontal and vertical
* indices.
*
* @param {int} h Horizontal index of the target slide
* @param {int} v Vertical index of the target slide
* @param {int} f Optional index of a fragment within the
* target slide to activate
* @param {int} o Optional origin for use in multimaster environments
*/
function slide( h, v, f, o ) {
// Remember where we were at before
previousSlide = currentSlide;
// Query all horizontal slides in the deck
var horizontalSlides = dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR );
// If no vertical index is specified and the upcoming slide is a
// stack, resume at its previous vertical index
if( v === undefined && !isOverview() ) {
v = getPreviousVerticalIndex( horizontalSlides[ h ] );
}
// If we were on a vertical stack, remember what vertical index
// it was on so we can resume at the same position when returning
if( previousSlide && previousSlide.parentNode && previousSlide.parentNode.classList.contains( 'stack' ) ) {
setPreviousVerticalIndex( previousSlide.parentNode, indexv );
}
// Remember the state before this slide
var stateBefore = state.concat();
// Reset the state array
state.length = 0;
var indexhBefore = indexh || 0,
indexvBefore = indexv || 0;
// Activate and transition to the new slide
indexh = updateSlides( HORIZONTAL_SLIDES_SELECTOR, h === undefined ? indexh : h );
indexv = updateSlides( VERTICAL_SLIDES_SELECTOR, v === undefined ? indexv : v );
// Update the visibility of slides now that the indices have changed
updateSlidesVisibility();
layout();
// Apply the new state
stateLoop: for( var i = 0, len = state.length; i < len; i++ ) {
// Check if this state existed on the previous slide. If it
// did, we will avoid adding it repeatedly
for( var j = 0; j < stateBefore.length; j++ ) {
if( stateBefore[j] === state[i] ) {
stateBefore.splice( j, 1 );
continue stateLoop;
}
}
document.documentElement.classList.add( state[i] );
// Dispatch custom event matching the state's name
dispatchEvent( state[i] );
}
// Clean up the remains of the previous state
while( stateBefore.length ) {
document.documentElement.classList.remove( stateBefore.pop() );
}
// Update the overview if it's currently active
if( isOverview() ) {
updateOverview();
}
// Find the current horizontal slide and any possible vertical slides
// within it
var currentHorizontalSlide = horizontalSlides[ indexh ],
currentVerticalSlides = currentHorizontalSlide.querySelectorAll( 'section' );
// Store references to the previous and current slides
currentSlide = currentVerticalSlides[ indexv ] || currentHorizontalSlide;
// Show fragment, if specified
if( typeof f !== 'undefined' ) {
navigateFragment( f );
}
// Dispatch an event if the slide changed
var slideChanged = ( indexh !== indexhBefore || indexv !== indexvBefore );
if( slideChanged ) {
dispatchEvent( 'slidechanged', {
'indexh': indexh,
'indexv': indexv,
'previousSlide': previousSlide,
'currentSlide': currentSlide,
'origin': o
} );
}
else {
// Ensure that the previous slide is never the same as the current
previousSlide = null;
}
// Solves an edge case where the previous slide maintains the
// 'present' class when navigating between adjacent vertical
// stacks
if( previousSlide ) {
previousSlide.classList.remove( 'present' );
previousSlide.setAttribute( 'aria-hidden', 'true' );
// Reset all slides upon navigate to home
// Issue: #285
if ( dom.wrapper.querySelector( HOME_SLIDE_SELECTOR ).classList.contains( 'present' ) ) {
// Launch async task
setTimeout( function () {
var slides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR + '.stack') ), i;
for( i in slides ) {
if( slides[i] ) {
// Reset stack
setPreviousVerticalIndex( slides[i], 0 );
}
}
}, 0 );
}
}
// Handle embedded content
if( slideChanged || !previousSlide ) {
stopEmbeddedContent( previousSlide );
startEmbeddedContent( currentSlide );
}
// Announce the current slide contents, for screen readers
dom.statusDiv.textContent = currentSlide.textContent;
updateControls();
updateProgress();
updateBackground();
updateParallax();
updateSlideNumber();
updateNotes();
// Update the URL hash
writeURL();
cueAutoSlide();
}
/**
* Syncs the presentation with the current DOM. Useful
* when new slides or control elements are added or when
* the configuration has changed.
*/
function sync() {
// Subscribe to input
removeEventListeners();
addEventListeners();
// Force a layout to make sure the current config is accounted for
layout();
// Reflect the current autoSlide value
autoSlide = config.autoSlide;
// Start auto-sliding if it's enabled
cueAutoSlide();
// Re-create the slide backgrounds
createBackgrounds();
// Write the current hash to the URL
writeURL();
sortAllFragments();
updateControls();
updateProgress();
updateBackground( true );
updateSlideNumber();
updateSlidesVisibility();
updateNotes();
formatEmbeddedContent();
startEmbeddedContent( currentSlide );
if( isOverview() ) {
layoutOverview();
}
}
/**
* Resets all vertical slides so that only the first
* is visible.
*/
function resetVerticalSlides() {
var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
horizontalSlides.forEach( function( horizontalSlide ) {
var verticalSlides = toArray( horizontalSlide.querySelectorAll( 'section' ) );
verticalSlides.forEach( function( verticalSlide, y ) {
if( y > 0 ) {
verticalSlide.classList.remove( 'present' );
verticalSlide.classList.remove( 'past' );
verticalSlide.classList.add( 'future' );
verticalSlide.setAttribute( 'aria-hidden', 'true' );
}
} );
} );
}
/**
* Sorts and formats all of fragments in the
* presentation.
*/
function sortAllFragments() {
var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
horizontalSlides.forEach( function( horizontalSlide ) {
var verticalSlides = toArray( horizontalSlide.querySelectorAll( 'section' ) );
verticalSlides.forEach( function( verticalSlide, y ) {
sortFragments( verticalSlide.querySelectorAll( '.fragment' ) );
} );
if( verticalSlides.length === 0 ) sortFragments( horizontalSlide.querySelectorAll( '.fragment' ) );
} );
}
/**
* Randomly shuffles all slides in the deck.
*/
function shuffle() {
var slides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
slides.forEach( function( slide ) {
// Insert this slide next to another random slide. This may
// cause the slide to insert before itself but that's fine.
dom.slides.insertBefore( slide, slides[ Math.floor( Math.random() * slides.length ) ] );
} );
}
/**
* Updates one dimension of slides by showing the slide
* with the specified index.
*
* @param {String} selector A CSS selector that will fetch
* the group of slides we are working with
* @param {Number} index The index of the slide that should be
* shown
*
* @return {Number} The index of the slide that is now shown,
* might differ from the passed in index if it was out of
* bounds.
*/
function updateSlides( selector, index ) {
// Select all slides and convert the NodeList result to
// an array
var slides = toArray( dom.wrapper.querySelectorAll( selector ) ),
slidesLength = slides.length;
var printMode = isPrintingPDF();
if( slidesLength ) {
// Should the index loop?
if( config.loop ) {
index %= slidesLength;
if( index < 0 ) {
index = slidesLength + index;
}
}
// Enforce max and minimum index bounds
index = Math.max( Math.min( index, slidesLength - 1 ), 0 );
for( var i = 0; i < slidesLength; i++ ) {
var element = slides[i];
var reverse = config.rtl && !isVerticalSlide( element );
element.classList.remove( 'past' );
element.classList.remove( 'present' );
element.classList.remove( 'future' );
// http://www.w3.org/html/wg/drafts/html/master/editing.html#the-hidden-attribute
element.setAttribute( 'hidden', '' );
element.setAttribute( 'aria-hidden', 'true' );
// If this element contains vertical slides
if( element.querySelector( 'section' ) ) {
element.classList.add( 'stack' );
}
// If we're printing static slides, all slides are "present"
if( printMode ) {
element.classList.add( 'present' );
continue;
}
if( i < index ) {
// Any element previous to index is given the 'past' class
element.classList.add( reverse ? 'future' : 'past' );
if( config.fragments ) {
var pastFragments = toArray( element.querySelectorAll( '.fragment' ) );
// Show all fragments on prior slides
while( pastFragments.length ) {
var pastFragment = pastFragments.pop();
pastFragment.classList.add( 'visible' );
pastFragment.classList.remove( 'current-fragment' );
}
}
}
else if( i > index ) {
// Any element subsequent to index is given the 'future' class
element.classList.add( reverse ? 'past' : 'future' );
if( config.fragments ) {
var futureFragments = toArray( element.querySelectorAll( '.fragment.visible' ) );
// No fragments in future slides should be visible ahead of time
while( futureFragments.length ) {
var futureFragment = futureFragments.pop();
futureFragment.classList.remove( 'visible' );
futureFragment.classList.remove( 'current-fragment' );
}
}
}
}
// Mark the current slide as present
slides[index].classList.add( 'present' );
slides[index].removeAttribute( 'hidden' );
slides[index].removeAttribute( 'aria-hidden' );
// If this slide has a state associated with it, add it
// onto the current state of the deck
var slideState = slides[index].getAttribute( 'data-state' );
if( slideState ) {
state = state.concat( slideState.split( ' ' ) );
}
}
else {
// Since there are no slides we can't be anywhere beyond the
// zeroth index
index = 0;
}
return index;
}
/**
* Optimization method; hide all slides that are far away
* from the present slide.
*/
function updateSlidesVisibility() {
// Select all slides and convert the NodeList result to
// an array
var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ),
horizontalSlidesLength = horizontalSlides.length,
distanceX,
distanceY;
if( horizontalSlidesLength && typeof indexh !== 'undefined' ) {
// The number of steps away from the present slide that will
// be visible
var viewDistance = isOverview() ? 10 : config.viewDistance;
// Limit view distance on weaker devices
if( isMobileDevice ) {
viewDistance = isOverview() ? 6 : 2;
}
// All slides need to be visible when exporting to PDF
if( isPrintingPDF() ) {
viewDistance = Number.MAX_VALUE;
}
for( var x = 0; x < horizontalSlidesLength; x++ ) {
var horizontalSlide = horizontalSlides[x];
var verticalSlides = toArray( horizontalSlide.querySelectorAll( 'section' ) ),
verticalSlidesLength = verticalSlides.length;
// Determine how far away this slide is from the present
distanceX = Math.abs( ( indexh || 0 ) - x ) || 0;
// If the presentation is looped, distance should measure
// 1 between the first and last slides
if( config.loop ) {
distanceX = Math.abs( ( ( indexh || 0 ) - x ) % ( horizontalSlidesLength - viewDistance ) ) || 0;
}
// Show the horizontal slide if it's within the view distance
if( distanceX < viewDistance ) {
showSlide( horizontalSlide );
}
else {
hideSlide( horizontalSlide );
}
if( verticalSlidesLength ) {
var oy = getPreviousVerticalIndex( horizontalSlide );
for( var y = 0; y < verticalSlidesLength; y++ ) {
var verticalSlide = verticalSlides[y];
distanceY = x === ( indexh || 0 ) ? Math.abs( ( indexv || 0 ) - y ) : Math.abs( y - oy );
if( distanceX + distanceY < viewDistance ) {
showSlide( verticalSlide );
}
else {
hideSlide( verticalSlide );
}
}
}
}
}
}
/**
* Pick up notes from the current slide and display tham
* to the viewer.
*
* @see `showNotes` config value
*/
function updateNotes() {
if( config.showNotes && dom.speakerNotes && currentSlide && !isPrintingPDF() ) {
dom.speakerNotes.innerHTML = getSlideNotes() || '';
}
}
/**
* Updates the progress bar to reflect the current slide.
*/
function updateProgress() {
// Update progress if enabled
if( config.progress && dom.progressbar ) {
dom.progressbar.style.width = getProgress() * dom.wrapper.offsetWidth + 'px';
}
}
/**
* Updates the slide number div to reflect the current slide.
*
* The following slide number formats are available:
* "h.v": horizontal . vertical slide number (default)
* "h/v": horizontal / vertical slide number
* "c": flattened slide number
* "c/t": flattened slide number / total slides
*/
function updateSlideNumber() {
// Update slide number if enabled
if( config.slideNumber && dom.slideNumber ) {
var value = [];
var format = 'h.v';
// Check if a custom number format is available
if( typeof config.slideNumber === 'string' ) {
format = config.slideNumber;
}
switch( format ) {
case 'c':
value.push( getSlidePastCount() + 1 );
break;
case 'c/t':
value.push( getSlidePastCount() + 1, '/', getTotalSlides() );
break;
case 'h/v':
value.push( indexh + 1 );
if( isVerticalSlide() ) value.push( '/', indexv + 1 );
break;
default:
value.push( indexh + 1 );
if( isVerticalSlide() ) value.push( '.', indexv + 1 );
}
dom.slideNumber.innerHTML = formatSlideNumber( value[0], value[1], value[2] );
}
}
/**
* Applies HTML formatting to a slide number before it's
* written to the DOM.
*/
function formatSlideNumber( a, delimiter, b ) {
if( typeof b === 'number' && !isNaN( b ) ) {
return '<span class="slide-number-a">'+ a +'</span>' +
'<span class="slide-number-delimiter">'+ delimiter +'</span>' +
'<span class="slide-number-b">'+ b +'</span>';
}
else {
return '<span class="slide-number-a">'+ a +'</span>';
}
}
/**
* Updates the state of all control/navigation arrows.
*/
function updateControls() {
var routes = availableRoutes();
var fragments = availableFragments();
// Remove the 'enabled' class from all directions
dom.controlsLeft.concat( dom.controlsRight )
.concat( dom.controlsUp )
.concat( dom.controlsDown )
.concat( dom.controlsPrev )
.concat( dom.controlsNext ).forEach( function( node ) {
node.classList.remove( 'enabled' );
node.classList.remove( 'fragmented' );
} );
// Add the 'enabled' class to the available routes
if( routes.left ) dom.controlsLeft.forEach( function( el ) { el.classList.add( 'enabled' ); } );
if( routes.right ) dom.controlsRight.forEach( function( el ) { el.classList.add( 'enabled' ); } );
if( routes.up ) dom.controlsUp.forEach( function( el ) { el.classList.add( 'enabled' ); } );
if( routes.down ) dom.controlsDown.forEach( function( el ) { el.classList.add( 'enabled' ); } );
// Prev/next buttons
if( routes.left || routes.up ) dom.controlsPrev.forEach( function( el ) { el.classList.add( 'enabled' ); } );
if( routes.right || routes.down ) dom.controlsNext.forEach( function( el ) { el.classList.add( 'enabled' ); } );
// Highlight fragment directions
if( currentSlide ) {
// Always apply fragment decorator to prev/next buttons
if( fragments.prev ) dom.controlsPrev.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
if( fragments.next ) dom.controlsNext.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
// Apply fragment decorators to directional buttons based on
// what slide axis they are in
if( isVerticalSlide( currentSlide ) ) {
if( fragments.prev ) dom.controlsUp.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
if( fragments.next ) dom.controlsDown.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
}
else {
if( fragments.prev ) dom.controlsLeft.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
if( fragments.next ) dom.controlsRight.forEach( function( el ) { el.classList.add( 'fragmented', 'enabled' ); } );
}
}
}
/**
* Updates the background elements to reflect the current
* slide.
*
* @param {Boolean} includeAll If true, the backgrounds of
* all vertical slides (not just the present) will be updated.
*/
function updateBackground( includeAll ) {
var currentBackground = null;
// Reverse past/future classes when in RTL mode
var horizontalPast = config.rtl ? 'future' : 'past',
horizontalFuture = config.rtl ? 'past' : 'future';
// Update the classes of all backgrounds to match the
// states of their slides (past/present/future)
toArray( dom.background.childNodes ).forEach( function( backgroundh, h ) {
backgroundh.classList.remove( 'past' );
backgroundh.classList.remove( 'present' );
backgroundh.classList.remove( 'future' );
if( h < indexh ) {
backgroundh.classList.add( horizontalPast );
}
else if ( h > indexh ) {
backgroundh.classList.add( horizontalFuture );
}
else {
backgroundh.classList.add( 'present' );
// Store a reference to the current background element
currentBackground = backgroundh;
}
if( includeAll || h === indexh ) {
toArray( backgroundh.querySelectorAll( '.slide-background' ) ).forEach( function( backgroundv, v ) {
backgroundv.classList.remove( 'past' );
backgroundv.classList.remove( 'present' );
backgroundv.classList.remove( 'future' );
if( v < indexv ) {
backgroundv.classList.add( 'past' );
}
else if ( v > indexv ) {
backgroundv.classList.add( 'future' );
}
else {
backgroundv.classList.add( 'present' );
// Only if this is the present horizontal and vertical slide
if( h === indexh ) currentBackground = backgroundv;
}
} );
}
} );
// Stop any currently playing video background
if( previousBackground ) {
var previousVideo = previousBackground.querySelector( 'video' );
if( previousVideo ) previousVideo.pause();
}
if( currentBackground ) {
// Start video playback
var currentVideo = currentBackground.querySelector( 'video' );
if( currentVideo ) {
var startVideo = function() {
currentVideo.currentTime = 0;
currentVideo.play();
currentVideo.removeEventListener( 'loadeddata', startVideo );
};
if( currentVideo.readyState > 1 ) {
startVideo();
}
else {
currentVideo.addEventListener( 'loadeddata', startVideo );
}
}
var backgroundImageURL = currentBackground.style.backgroundImage || '';
// Restart GIFs (doesn't work in Firefox)
if( /\.gif/i.test( backgroundImageURL ) ) {
currentBackground.style.backgroundImage = '';
window.getComputedStyle( currentBackground ).opacity;
currentBackground.style.backgroundImage = backgroundImageURL;
}
// Don't transition between identical backgrounds. This
// prevents unwanted flicker.
var previousBackgroundHash = previousBackground ? previousBackground.getAttribute( 'data-background-hash' ) : null;
var currentBackgroundHash = currentBackground.getAttribute( 'data-background-hash' );
if( currentBackgroundHash && currentBackgroundHash === previousBackgroundHash && currentBackground !== previousBackground ) {
dom.background.classList.add( 'no-transition' );
}
previousBackground = currentBackground;
}
// If there's a background brightness flag for this slide,
// bubble it to the .reveal container
if( currentSlide ) {
[ 'has-light-background', 'has-dark-background' ].forEach( function( classToBubble ) {
if( currentSlide.classList.contains( classToBubble ) ) {
dom.wrapper.classList.add( classToBubble );
}
else {
dom.wrapper.classList.remove( classToBubble );
}
} );
}
// Allow the first background to apply without transition
setTimeout( function() {
dom.background.classList.remove( 'no-transition' );
}, 1 );
}
/**
* Updates the position of the parallax background based
* on the current slide index.
*/
function updateParallax() {
if( config.parallaxBackgroundImage ) {
var horizontalSlides = dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ),
verticalSlides = dom.wrapper.querySelectorAll( VERTICAL_SLIDES_SELECTOR );
var backgroundSize = dom.background.style.backgroundSize.split( ' ' ),
backgroundWidth, backgroundHeight;
if( backgroundSize.length === 1 ) {
backgroundWidth = backgroundHeight = parseInt( backgroundSize[0], 10 );
}
else {
backgroundWidth = parseInt( backgroundSize[0], 10 );
backgroundHeight = parseInt( backgroundSize[1], 10 );
}
var slideWidth = dom.background.offsetWidth,
horizontalSlideCount = horizontalSlides.length,
horizontalOffsetMultiplier,
horizontalOffset;
if( typeof config.parallaxBackgroundHorizontal === 'number' ) {
horizontalOffsetMultiplier = config.parallaxBackgroundHorizontal;
}
else {
horizontalOffsetMultiplier = horizontalSlideCount > 1 ? ( backgroundWidth - slideWidth ) / ( horizontalSlideCount-1 ) : 0;
}
horizontalOffset = horizontalOffsetMultiplier * indexh * -1;
var slideHeight = dom.background.offsetHeight,
verticalSlideCount = verticalSlides.length,
verticalOffsetMultiplier,
verticalOffset;
if( typeof config.parallaxBackgroundVertical === 'number' ) {
verticalOffsetMultiplier = config.parallaxBackgroundVertical;
}
else {
verticalOffsetMultiplier = ( backgroundHeight - slideHeight ) / ( verticalSlideCount-1 );
}
verticalOffset = verticalSlideCount > 0 ? verticalOffsetMultiplier * indexv * 1 : 0;
dom.background.style.backgroundPosition = horizontalOffset + 'px ' + -verticalOffset + 'px';
}
}
/**
* Called when the given slide is within the configured view
* distance. Shows the slide element and loads any content
* that is set to load lazily (data-src).
*/
function showSlide( slide ) {
// Show the slide element
slide.style.display = 'block';
// Media elements with data-src attributes
toArray( slide.querySelectorAll( 'img[data-src], video[data-src], audio[data-src]' ) ).forEach( function( element ) {
element.setAttribute( 'src', element.getAttribute( 'data-src' ) );
element.removeAttribute( 'data-src' );
} );
// Media elements with <source> children
toArray( slide.querySelectorAll( 'video, audio' ) ).forEach( function( media ) {
var sources = 0;
toArray( media.querySelectorAll( 'source[data-src]' ) ).forEach( function( source ) {
source.setAttribute( 'src', source.getAttribute( 'data-src' ) );
source.removeAttribute( 'data-src' );
sources += 1;
} );
// If we rewrote sources for this video/audio element, we need
// to manually tell it to load from its new origin
if( sources > 0 ) {
media.load();
}
} );
// Show the corresponding background element
var indices = getIndices( slide );
var background = getSlideBackground( indices.h, indices.v );
if( background ) {
background.style.display = 'block';
// If the background contains media, load it
if( background.hasAttribute( 'data-loaded' ) === false ) {
background.setAttribute( 'data-loaded', 'true' );
var backgroundImage = slide.getAttribute( 'data-background-image' ),
backgroundVideo = slide.getAttribute( 'data-background-video' ),
backgroundVideoLoop = slide.hasAttribute( 'data-background-video-loop' ),
backgroundVideoMuted = slide.hasAttribute( 'data-background-video-muted' ),
backgroundIframe = slide.getAttribute( 'data-background-iframe' );
// Images
if( backgroundImage ) {
background.style.backgroundImage = 'url('+ backgroundImage +')';
}
// Videos
else if ( backgroundVideo && !isSpeakerNotes() ) {
var video = document.createElement( 'video' );
if( backgroundVideoLoop ) {
video.setAttribute( 'loop', '' );
}
if( backgroundVideoMuted ) {
video.muted = true;
}
// Support comma separated lists of video sources
backgroundVideo.split( ',' ).forEach( function( source ) {
video.innerHTML += '<source src="'+ source +'">';
} );
background.appendChild( video );
}
// Iframes
else if( backgroundIframe ) {
var iframe = document.createElement( 'iframe' );
iframe.setAttribute( 'src', backgroundIframe );
iframe.style.width = '100%';
iframe.style.height = '100%';
iframe.style.maxHeight = '100%';
iframe.style.maxWidth = '100%';
background.appendChild( iframe );
}
}
}
}
/**
* Called when the given slide is moved outside of the
* configured view distance.
*/
function hideSlide( slide ) {
// Hide the slide element
slide.style.display = 'none';
// Hide the corresponding background element
var indices = getIndices( slide );
var background = getSlideBackground( indices.h, indices.v );
if( background ) {
background.style.display = 'none';
}
}
/**
* Determine what available routes there are for navigation.
*
* @return {Object} containing four booleans: left/right/up/down
*/
function availableRoutes() {
var horizontalSlides = dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ),
verticalSlides = dom.wrapper.querySelectorAll( VERTICAL_SLIDES_SELECTOR );
var routes = {
left: indexh > 0 || config.loop,
right: indexh < horizontalSlides.length - 1 || config.loop,
up: indexv > 0,
down: indexv < verticalSlides.length - 1
};
// reverse horizontal controls for rtl
if( config.rtl ) {
var left = routes.left;
routes.left = routes.right;
routes.right = left;
}
return routes;
}
/**
* Returns an object describing the available fragment
* directions.
*
* @return {Object} two boolean properties: prev/next
*/
function availableFragments() {
if( currentSlide && config.fragments ) {
var fragments = currentSlide.querySelectorAll( '.fragment' );
var hiddenFragments = currentSlide.querySelectorAll( '.fragment:not(.visible)' );
return {
prev: fragments.length - hiddenFragments.length > 0,
next: !!hiddenFragments.length
};
}
else {
return { prev: false, next: false };
}
}
/**
* Enforces origin-specific format rules for embedded media.
*/
function formatEmbeddedContent() {
var _appendParamToIframeSource = function( sourceAttribute, sourceURL, param ) {
toArray( dom.slides.querySelectorAll( 'iframe['+ sourceAttribute +'*="'+ sourceURL +'"]' ) ).forEach( function( el ) {
var src = el.getAttribute( sourceAttribute );
if( src && src.indexOf( param ) === -1 ) {
el.setAttribute( sourceAttribute, src + ( !/\?/.test( src ) ? '?' : '&' ) + param );
}
});
};
// YouTube frames must include "?enablejsapi=1"
_appendParamToIframeSource( 'src', 'youtube.com/embed/', 'enablejsapi=1' );
_appendParamToIframeSource( 'data-src', 'youtube.com/embed/', 'enablejsapi=1' );
// Vimeo frames must include "?api=1"
_appendParamToIframeSource( 'src', 'player.vimeo.com/', 'api=1' );
_appendParamToIframeSource( 'data-src', 'player.vimeo.com/', 'api=1' );
}
/**
* Start playback of any embedded content inside of
* the targeted slide.
*/
function startEmbeddedContent( slide ) {
if( slide && !isSpeakerNotes() ) {
// Restart GIFs
toArray( slide.querySelectorAll( 'img[src$=".gif"]' ) ).forEach( function( el ) {
// Setting the same unchanged source like this was confirmed
// to work in Chrome, FF & Safari
el.setAttribute( 'src', el.getAttribute( 'src' ) );
} );
// HTML5 media elements
toArray( slide.querySelectorAll( 'video, audio' ) ).forEach( function( el ) {
if( el.hasAttribute( 'data-autoplay' ) && typeof el.play === 'function' ) {
el.play();
}
} );
// Normal iframes
toArray( slide.querySelectorAll( 'iframe[src]' ) ).forEach( function( el ) {
startEmbeddedIframe( { target: el } );
} );
// Lazy loading iframes
toArray( slide.querySelectorAll( 'iframe[data-src]' ) ).forEach( function( el ) {
if( el.getAttribute( 'src' ) !== el.getAttribute( 'data-src' ) ) {
el.removeEventListener( 'load', startEmbeddedIframe ); // remove first to avoid dupes
el.addEventListener( 'load', startEmbeddedIframe );
el.setAttribute( 'src', el.getAttribute( 'data-src' ) );
}
} );
}
}
/**
* "Starts" the content of an embedded iframe using the
* postmessage API.
*/
function startEmbeddedIframe( event ) {
var iframe = event.target;
// YouTube postMessage API
if( /youtube\.com\/embed\//.test( iframe.getAttribute( 'src' ) ) && iframe.hasAttribute( 'data-autoplay' ) ) {
iframe.contentWindow.postMessage( '{"event":"command","func":"playVideo","args":""}', '*' );
}
// Vimeo postMessage API
else if( /player\.vimeo\.com\//.test( iframe.getAttribute( 'src' ) ) && iframe.hasAttribute( 'data-autoplay' ) ) {
iframe.contentWindow.postMessage( '{"method":"play"}', '*' );
}
// Generic postMessage API
else {
iframe.contentWindow.postMessage( 'slide:start', '*' );
}
}
/**
* Stop playback of any embedded content inside of
* the targeted slide.
*/
function stopEmbeddedContent( slide ) {
if( slide && slide.parentNode ) {
// HTML5 media elements
toArray( slide.querySelectorAll( 'video, audio' ) ).forEach( function( el ) {
if( !el.hasAttribute( 'data-ignore' ) && typeof el.pause === 'function' ) {
el.pause();
}
} );
// Generic postMessage API for non-lazy loaded iframes
toArray( slide.querySelectorAll( 'iframe' ) ).forEach( function( el ) {
el.contentWindow.postMessage( 'slide:stop', '*' );
el.removeEventListener( 'load', startEmbeddedIframe );
});
// YouTube postMessage API
toArray( slide.querySelectorAll( 'iframe[src*="youtube.com/embed/"]' ) ).forEach( function( el ) {
if( !el.hasAttribute( 'data-ignore' ) && typeof el.contentWindow.postMessage === 'function' ) {
el.contentWindow.postMessage( '{"event":"command","func":"pauseVideo","args":""}', '*' );
}
});
// Vimeo postMessage API
toArray( slide.querySelectorAll( 'iframe[src*="player.vimeo.com/"]' ) ).forEach( function( el ) {
if( !el.hasAttribute( 'data-ignore' ) && typeof el.contentWindow.postMessage === 'function' ) {
el.contentWindow.postMessage( '{"method":"pause"}', '*' );
}
});
// Lazy loading iframes
toArray( slide.querySelectorAll( 'iframe[data-src]' ) ).forEach( function( el ) {
// Only removing the src doesn't actually unload the frame
// in all browsers (Firefox) so we set it to blank first
el.setAttribute( 'src', 'about:blank' );
el.removeAttribute( 'src' );
} );
}
}
/**
* Returns the number of past slides. This can be used as a global
* flattened index for slides.
*/
function getSlidePastCount() {
var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
// The number of past slides
var pastCount = 0;
// Step through all slides and count the past ones
mainLoop: for( var i = 0; i < horizontalSlides.length; i++ ) {
var horizontalSlide = horizontalSlides[i];
var verticalSlides = toArray( horizontalSlide.querySelectorAll( 'section' ) );
for( var j = 0; j < verticalSlides.length; j++ ) {
// Stop as soon as we arrive at the present
if( verticalSlides[j].classList.contains( 'present' ) ) {
break mainLoop;
}
pastCount++;
}
// Stop as soon as we arrive at the present
if( horizontalSlide.classList.contains( 'present' ) ) {
break;
}
// Don't count the wrapping section for vertical slides
if( horizontalSlide.classList.contains( 'stack' ) === false ) {
pastCount++;
}
}
return pastCount;
}
/**
* Returns a value ranging from 0-1 that represents
* how far into the presentation we have navigated.
*/
function getProgress() {
// The number of past and total slides
var totalCount = getTotalSlides();
var pastCount = getSlidePastCount();
if( currentSlide ) {
var allFragments = currentSlide.querySelectorAll( '.fragment' );
// If there are fragments in the current slide those should be
// accounted for in the progress.
if( allFragments.length > 0 ) {
var visibleFragments = currentSlide.querySelectorAll( '.fragment.visible' );
// This value represents how big a portion of the slide progress
// that is made up by its fragments (0-1)
var fragmentWeight = 0.9;
// Add fragment progress to the past slide count
pastCount += ( visibleFragments.length / allFragments.length ) * fragmentWeight;
}
}
return pastCount / ( totalCount - 1 );
}
/**
* Checks if this presentation is running inside of the
* speaker notes window.
*/
function isSpeakerNotes() {
return !!window.location.search.match( /receiver/gi );
}
/**
* Reads the current URL (hash) and navigates accordingly.
*/
function readURL() {
var hash = window.location.hash;
// Attempt to parse the hash as either an index or name
var bits = hash.slice( 2 ).split( '/' ),
name = hash.replace( /#|\//gi, '' );
// If the first bit is invalid and there is a name we can
// assume that this is a named link
if( isNaN( parseInt( bits[0], 10 ) ) && name.length ) {
var element;
// Ensure the named link is a valid HTML ID attribute
if( /^[a-zA-Z][\w:.-]*$/.test( name ) ) {
// Find the slide with the specified ID
element = document.getElementById( name );
}
if( element ) {
// Find the position of the named slide and navigate to it
var indices = Reveal.getIndices( element );
slide( indices.h, indices.v );
}
// If the slide doesn't exist, navigate to the current slide
else {
slide( indexh || 0, indexv || 0 );
}
}
else {
// Read the index components of the hash
var h = parseInt( bits[0], 10 ) || 0,
v = parseInt( bits[1], 10 ) || 0;
if( h !== indexh || v !== indexv ) {
slide( h, v );
}
}
}
/**
* Updates the page URL (hash) to reflect the current
* state.
*
* @param {Number} delay The time in ms to wait before
* writing the hash
*/
function writeURL( delay ) {
if( config.history ) {
// Make sure there's never more than one timeout running
clearTimeout( writeURLTimeout );
// If a delay is specified, timeout this call
if( typeof delay === 'number' ) {
writeURLTimeout = setTimeout( writeURL, delay );
}
else if( currentSlide ) {
var url = '/';
// Attempt to create a named link based on the slide's ID
var id = currentSlide.getAttribute( 'id' );
if( id ) {
id = id.replace( /[^a-zA-Z0-9\-\_\:\.]/g, '' );
}
// If the current slide has an ID, use that as a named link
if( typeof id === 'string' && id.length ) {
url = '/' + id;
}
// Otherwise use the /h/v index
else {
if( indexh > 0 || indexv > 0 ) url += indexh;
if( indexv > 0 ) url += '/' + indexv;
}
window.location.hash = url;
}
}
}
/**
* Retrieves the h/v location of the current, or specified,
* slide.
*
* @param {HTMLElement} slide If specified, the returned
* index will be for this slide rather than the currently
* active one
*
* @return {Object} { h: <int>, v: <int>, f: <int> }
*/
function getIndices( slide ) {
// By default, return the current indices
var h = indexh,
v = indexv,
f;
// If a slide is specified, return the indices of that slide
if( slide ) {
var isVertical = isVerticalSlide( slide );
var slideh = isVertical ? slide.parentNode : slide;
// Select all horizontal slides
var horizontalSlides = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) );
// Now that we know which the horizontal slide is, get its index
h = Math.max( horizontalSlides.indexOf( slideh ), 0 );
// Assume we're not vertical
v = undefined;
// If this is a vertical slide, grab the vertical index
if( isVertical ) {
v = Math.max( toArray( slide.parentNode.querySelectorAll( 'section' ) ).indexOf( slide ), 0 );
}
}
if( !slide && currentSlide ) {
var hasFragments = currentSlide.querySelectorAll( '.fragment' ).length > 0;
if( hasFragments ) {
var currentFragment = currentSlide.querySelector( '.current-fragment' );
if( currentFragment && currentFragment.hasAttribute( 'data-fragment-index' ) ) {
f = parseInt( currentFragment.getAttribute( 'data-fragment-index' ), 10 );
}
else {
f = currentSlide.querySelectorAll( '.fragment.visible' ).length - 1;
}
}
}
return { h: h, v: v, f: f };
}
/**
* Retrieves the total number of slides in this presentation.
*/
function getTotalSlides() {
return dom.wrapper.querySelectorAll( SLIDES_SELECTOR + ':not(.stack)' ).length;
}
/**
* Returns the slide element matching the specified index.
*/
function getSlide( x, y ) {
var horizontalSlide = dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR )[ x ];
var verticalSlides = horizontalSlide && horizontalSlide.querySelectorAll( 'section' );
if( verticalSlides && verticalSlides.length && typeof y === 'number' ) {
return verticalSlides ? verticalSlides[ y ] : undefined;
}
return horizontalSlide;
}
/**
* Returns the background element for the given slide.
* All slides, even the ones with no background properties
* defined, have a background element so as long as the
* index is valid an element will be returned.
*/
function getSlideBackground( x, y ) {
// When printing to PDF the slide backgrounds are nested
// inside of the slides
if( isPrintingPDF() ) {
var slide = getSlide( x, y );
if( slide ) {
var background = slide.querySelector( '.slide-background' );
if( background && background.parentNode === slide ) {
return background;
}
}
return undefined;
}
var horizontalBackground = dom.wrapper.querySelectorAll( '.backgrounds>.slide-background' )[ x ];
var verticalBackgrounds = horizontalBackground && horizontalBackground.querySelectorAll( '.slide-background' );
if( verticalBackgrounds && verticalBackgrounds.length && typeof y === 'number' ) {
return verticalBackgrounds ? verticalBackgrounds[ y ] : undefined;
}
return horizontalBackground;
}
/**
* Retrieves the speaker notes from a slide. Notes can be
* defined in two ways:
* 1. As a data-notes attribute on the slide <section>
* 2. As an <aside class="notes"> inside of the slide
*/
function getSlideNotes( slide ) {
// Default to the current slide
slide = slide || currentSlide;
// Notes can be specified via the data-notes attribute...
if( slide.hasAttribute( 'data-notes' ) ) {
return slide.getAttribute( 'data-notes' );
}
// ... or using an <aside class="notes"> element
var notesElement = slide.querySelector( 'aside.notes' );
if( notesElement ) {
return notesElement.innerHTML;
}
return null;
}
/**
* Retrieves the current state of the presentation as
* an object. This state can then be restored at any
* time.
*/
function getState() {
var indices = getIndices();
return {
indexh: indices.h,
indexv: indices.v,
indexf: indices.f,
paused: isPaused(),
overview: isOverview()
};
}
/**
* Restores the presentation to the given state.
*
* @param {Object} state As generated by getState()
*/
function setState( state ) {
if( typeof state === 'object' ) {
slide( deserialize( state.indexh ), deserialize( state.indexv ), deserialize( state.indexf ) );
var pausedFlag = deserialize( state.paused ),
overviewFlag = deserialize( state.overview );
if( typeof pausedFlag === 'boolean' && pausedFlag !== isPaused() ) {
togglePause( pausedFlag );
}
if( typeof overviewFlag === 'boolean' && overviewFlag !== isOverview() ) {
toggleOverview( overviewFlag );
}
}
}
/**
* Return a sorted fragments list, ordered by an increasing
* "data-fragment-index" attribute.
*
* Fragments will be revealed in the order that they are returned by
* this function, so you can use the index attributes to control the
* order of fragment appearance.
*
* To maintain a sensible default fragment order, fragments are presumed
* to be passed in document order. This function adds a "fragment-index"
* attribute to each node if such an attribute is not already present,
* and sets that attribute to an integer value which is the position of
* the fragment within the fragments list.
*/
function sortFragments( fragments ) {
fragments = toArray( fragments );
var ordered = [],
unordered = [],
sorted = [];
// Group ordered and unordered elements
fragments.forEach( function( fragment, i ) {
if( fragment.hasAttribute( 'data-fragment-index' ) ) {
var index = parseInt( fragment.getAttribute( 'data-fragment-index' ), 10 );
if( !ordered[index] ) {
ordered[index] = [];
}
ordered[index].push( fragment );
}
else {
unordered.push( [ fragment ] );
}
} );
// Append fragments without explicit indices in their
// DOM order
ordered = ordered.concat( unordered );
// Manually count the index up per group to ensure there
// are no gaps
var index = 0;
// Push all fragments in their sorted order to an array,
// this flattens the groups
ordered.forEach( function( group ) {
group.forEach( function( fragment ) {
sorted.push( fragment );
fragment.setAttribute( 'data-fragment-index', index );
} );
index ++;
} );
return sorted;
}
/**
* Navigate to the specified slide fragment.
*
* @param {Number} index The index of the fragment that
* should be shown, -1 means all are invisible
* @param {Number} offset Integer offset to apply to the
* fragment index
*
* @return {Boolean} true if a change was made in any
* fragments visibility as part of this call
*/
function navigateFragment( index, offset ) {
if( currentSlide && config.fragments ) {
var fragments = sortFragments( currentSlide.querySelectorAll( '.fragment' ) );
if( fragments.length ) {
// If no index is specified, find the current
if( typeof index !== 'number' ) {
var lastVisibleFragment = sortFragments( currentSlide.querySelectorAll( '.fragment.visible' ) ).pop();
if( lastVisibleFragment ) {
index = parseInt( lastVisibleFragment.getAttribute( 'data-fragment-index' ) || 0, 10 );
}
else {
index = -1;
}
}
// If an offset is specified, apply it to the index
if( typeof offset === 'number' ) {
index += offset;
}
var fragmentsShown = [],
fragmentsHidden = [];
toArray( fragments ).forEach( function( element, i ) {
if( element.hasAttribute( 'data-fragment-index' ) ) {
i = parseInt( element.getAttribute( 'data-fragment-index' ), 10 );
}
// Visible fragments
if( i <= index ) {
if( !element.classList.contains( 'visible' ) ) fragmentsShown.push( element );
element.classList.add( 'visible' );
element.classList.remove( 'current-fragment' );
// Announce the fragments one by one to the Screen Reader
dom.statusDiv.textContent = element.textContent;
if( i === index ) {
element.classList.add( 'current-fragment' );
}
}
// Hidden fragments
else {
if( element.classList.contains( 'visible' ) ) fragmentsHidden.push( element );
element.classList.remove( 'visible' );
element.classList.remove( 'current-fragment' );
}
} );
if( fragmentsHidden.length ) {
dispatchEvent( 'fragmenthidden', { fragment: fragmentsHidden[0], fragments: fragmentsHidden } );
}
if( fragmentsShown.length ) {
dispatchEvent( 'fragmentshown', { fragment: fragmentsShown[0], fragments: fragmentsShown } );
}
updateControls();
updateProgress();
return !!( fragmentsShown.length || fragmentsHidden.length );
}
}
return false;
}
/**
* Navigate to the next slide fragment.
*
* @return {Boolean} true if there was a next fragment,
* false otherwise
*/
function nextFragment() {
return navigateFragment( null, 1 );
}
/**
* Navigate to the previous slide fragment.
*
* @return {Boolean} true if there was a previous fragment,
* false otherwise
*/
function previousFragment() {
return navigateFragment( null, -1 );
}
/**
* Cues a new automated slide if enabled in the config.
*/
function cueAutoSlide() {
cancelAutoSlide();
if( currentSlide ) {
var currentFragment = currentSlide.querySelector( '.current-fragment' );
var fragmentAutoSlide = currentFragment ? currentFragment.getAttribute( 'data-autoslide' ) : null;
var parentAutoSlide = currentSlide.parentNode ? currentSlide.parentNode.getAttribute( 'data-autoslide' ) : null;
var slideAutoSlide = currentSlide.getAttribute( 'data-autoslide' );
// Pick value in the following priority order:
// 1. Current fragment's data-autoslide
// 2. Current slide's data-autoslide
// 3. Parent slide's data-autoslide
// 4. Global autoSlide setting
if( fragmentAutoSlide ) {
autoSlide = parseInt( fragmentAutoSlide, 10 );
}
else if( slideAutoSlide ) {
autoSlide = parseInt( slideAutoSlide, 10 );
}
else if( parentAutoSlide ) {
autoSlide = parseInt( parentAutoSlide, 10 );
}
else {
autoSlide = config.autoSlide;
}
// If there are media elements with data-autoplay,
// automatically set the autoSlide duration to the
// length of that media. Not applicable if the slide
// is divided up into fragments.
if( currentSlide.querySelectorAll( '.fragment' ).length === 0 ) {
toArray( currentSlide.querySelectorAll( 'video, audio' ) ).forEach( function( el ) {
if( el.hasAttribute( 'data-autoplay' ) ) {
if( autoSlide && el.duration * 1000 > autoSlide ) {
autoSlide = ( el.duration * 1000 ) + 1000;
}
}
} );
}
// Cue the next auto-slide if:
// - There is an autoSlide value
// - Auto-sliding isn't paused by the user
// - The presentation isn't paused
// - The overview isn't active
// - The presentation isn't over
if( autoSlide && !autoSlidePaused && !isPaused() && !isOverview() && ( !Reveal.isLastSlide() || availableFragments().next || config.loop === true ) ) {
autoSlideTimeout = setTimeout( function() {
typeof config.autoSlideMethod === 'function' ? config.autoSlideMethod() : navigateNext();
cueAutoSlide();
}, autoSlide );
autoSlideStartTime = Date.now();
}
if( autoSlidePlayer ) {
autoSlidePlayer.setPlaying( autoSlideTimeout !== -1 );
}
}
}
/**
* Cancels any ongoing request to auto-slide.
*/
function cancelAutoSlide() {
clearTimeout( autoSlideTimeout );
autoSlideTimeout = -1;
}
function pauseAutoSlide() {
if( autoSlide && !autoSlidePaused ) {
autoSlidePaused = true;
dispatchEvent( 'autoslidepaused' );
clearTimeout( autoSlideTimeout );
if( autoSlidePlayer ) {
autoSlidePlayer.setPlaying( false );
}
}
}
function resumeAutoSlide() {
if( autoSlide && autoSlidePaused ) {
autoSlidePaused = false;
dispatchEvent( 'autoslideresumed' );
cueAutoSlide();
}
}
function navigateLeft() {
// Reverse for RTL
if( config.rtl ) {
if( ( isOverview() || nextFragment() === false ) && availableRoutes().left ) {
slide( indexh + 1 );
}
}
// Normal navigation
else if( ( isOverview() || previousFragment() === false ) && availableRoutes().left ) {
slide( indexh - 1 );
}
}
function navigateRight() {
// Reverse for RTL
if( config.rtl ) {
if( ( isOverview() || previousFragment() === false ) && availableRoutes().right ) {
slide( indexh - 1 );
}
}
// Normal navigation
else if( ( isOverview() || nextFragment() === false ) && availableRoutes().right ) {
slide( indexh + 1 );
}
}
function navigateUp() {
// Prioritize hiding fragments
if( ( isOverview() || previousFragment() === false ) && availableRoutes().up ) {
slide( indexh, indexv - 1 );
}
}
function navigateDown() {
// Prioritize revealing fragments
if( ( isOverview() || nextFragment() === false ) && availableRoutes().down ) {
slide( indexh, indexv + 1 );
}
}
/**
* Navigates backwards, prioritized in the following order:
* 1) Previous fragment
* 2) Previous vertical slide
* 3) Previous horizontal slide
*/
function navigatePrev() {
// Prioritize revealing fragments
if( previousFragment() === false ) {
if( availableRoutes().up ) {
navigateUp();
}
else {
// Fetch the previous horizontal slide, if there is one
var previousSlide;
if( config.rtl ) {
previousSlide = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR + '.future' ) ).pop();
}
else {
previousSlide = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR + '.past' ) ).pop();
}
if( previousSlide ) {
var v = ( previousSlide.querySelectorAll( 'section' ).length - 1 ) || undefined;
var h = indexh - 1;
slide( h, v );
}
}
}
}
/**
* The reverse of #navigatePrev().
*/
function navigateNext() {
// Prioritize revealing fragments
if( nextFragment() === false ) {
if( availableRoutes().down ) {
navigateDown();
}
else if( config.rtl ) {
navigateLeft();
}
else {
navigateRight();
}
}
}
/**
* Checks if the target element prevents the triggering of
* swipe navigation.
*/
function isSwipePrevented( target ) {
while( target && typeof target.hasAttribute === 'function' ) {
if( target.hasAttribute( 'data-prevent-swipe' ) ) return true;
target = target.parentNode;
}
return false;
}
// --------------------------------------------------------------------//
// ----------------------------- EVENTS -------------------------------//
// --------------------------------------------------------------------//
/**
* Called by all event handlers that are based on user
* input.
*/
function onUserInput( event ) {
if( config.autoSlideStoppable ) {
pauseAutoSlide();
}
}
/**
* Handler for the document level 'keypress' event.
*/
function onDocumentKeyPress( event ) {
// Check if the pressed key is question mark
if( event.shiftKey && event.charCode === 63 ) {
if( dom.overlay ) {
closeOverlay();
}
else {
showHelp( true );
}
}
}
/**
* Handler for the document level 'keydown' event.
*/
function onDocumentKeyDown( event ) {
// If there's a condition specified and it returns false,
// ignore this event
if( typeof config.keyboardCondition === 'function' && config.keyboardCondition() === false ) {
return true;
}
// Remember if auto-sliding was paused so we can toggle it
var autoSlideWasPaused = autoSlidePaused;
onUserInput( event );
// Check if there's a focused element that could be using
// the keyboard
var activeElementIsCE = document.activeElement && document.activeElement.contentEditable !== 'inherit';
var activeElementIsInput = document.activeElement && document.activeElement.tagName && /input|textarea/i.test( document.activeElement.tagName );
// Disregard the event if there's a focused element or a
// keyboard modifier key is present
if( activeElementIsCE || activeElementIsInput || (event.shiftKey && event.keyCode !== 32) || event.altKey || event.ctrlKey || event.metaKey ) return;
// While paused only allow resume keyboard events; 'b', '.''
var resumeKeyCodes = [66,190,191];
var key;
// Custom key bindings for togglePause should be able to resume
if( typeof config.keyboard === 'object' ) {
for( key in config.keyboard ) {
if( config.keyboard[key] === 'togglePause' ) {
resumeKeyCodes.push( parseInt( key, 10 ) );
}
}
}
if( isPaused() && resumeKeyCodes.indexOf( event.keyCode ) === -1 ) {
return false;
}
var triggered = false;
// 1. User defined key bindings
if( typeof config.keyboard === 'object' ) {
for( key in config.keyboard ) {
// Check if this binding matches the pressed key
if( parseInt( key, 10 ) === event.keyCode ) {
var value = config.keyboard[ key ];
// Callback function
if( typeof value === 'function' ) {
value.apply( null, [ event ] );
}
// String shortcuts to reveal.js API
else if( typeof value === 'string' && typeof Reveal[ value ] === 'function' ) {
Reveal[ value ].call();
}
triggered = true;
}
}
}
// 2. System defined key bindings
if( triggered === false ) {
// Assume true and try to prove false
triggered = true;
switch( event.keyCode ) {
// p, page up
case 80: case 33: navigatePrev(); break;
// n, page down
case 78: case 34: navigateNext(); break;
// h, left
case 72: case 37: navigateLeft(); break;
// l, right
case 76: case 39: navigateRight(); break;
// k, up
case 75: case 38: navigateUp(); break;
// j, down
case 74: case 40: navigateDown(); break;
// home
case 36: slide( 0 ); break;
// end
case 35: slide( Number.MAX_VALUE ); break;
// space
case 32: isOverview() ? deactivateOverview() : event.shiftKey ? navigatePrev() : navigateNext(); break;
// return
case 13: isOverview() ? deactivateOverview() : triggered = false; break;
// two-spot, semicolon, b, period, Logitech presenter tools "black screen" button
case 58: case 59: case 66: case 190: case 191: togglePause(); break;
// f
case 70: enterFullscreen(); break;
// a
case 65: if ( config.autoSlideStoppable ) toggleAutoSlide( autoSlideWasPaused ); break;
default:
triggered = false;
}
}
// If the input resulted in a triggered action we should prevent
// the browsers default behavior
if( triggered ) {
event.preventDefault && event.preventDefault();
}
// ESC or O key
else if ( ( event.keyCode === 27 || event.keyCode === 79 ) && features.transforms3d ) {
if( dom.overlay ) {
closeOverlay();
}
else {
toggleOverview();
}
event.preventDefault && event.preventDefault();
}
// If auto-sliding is enabled we need to cue up
// another timeout
cueAutoSlide();
}
/**
* Handler for the 'touchstart' event, enables support for
* swipe and pinch gestures.
*/
function onTouchStart( event ) {
if( isSwipePrevented( event.target ) ) return true;
touch.startX = event.touches[0].clientX;
touch.startY = event.touches[0].clientY;
touch.startCount = event.touches.length;
// If there's two touches we need to memorize the distance
// between those two points to detect pinching
if( event.touches.length === 2 && config.overview ) {
touch.startSpan = distanceBetween( {
x: event.touches[1].clientX,
y: event.touches[1].clientY
}, {
x: touch.startX,
y: touch.startY
} );
}
}
/**
* Handler for the 'touchmove' event.
*/
function onTouchMove( event ) {
if( isSwipePrevented( event.target ) ) return true;
// Each touch should only trigger one action
if( !touch.captured ) {
onUserInput( event );
var currentX = event.touches[0].clientX;
var currentY = event.touches[0].clientY;
// If the touch started with two points and still has
// two active touches; test for the pinch gesture
if( event.touches.length === 2 && touch.startCount === 2 && config.overview ) {
// The current distance in pixels between the two touch points
var currentSpan = distanceBetween( {
x: event.touches[1].clientX,
y: event.touches[1].clientY
}, {
x: touch.startX,
y: touch.startY
} );
// If the span is larger than the desire amount we've got
// ourselves a pinch
if( Math.abs( touch.startSpan - currentSpan ) > touch.threshold ) {
touch.captured = true;
if( currentSpan < touch.startSpan ) {
activateOverview();
}
else {
deactivateOverview();
}
}
event.preventDefault();
}
// There was only one touch point, look for a swipe
else if( event.touches.length === 1 && touch.startCount !== 2 ) {
var deltaX = currentX - touch.startX,
deltaY = currentY - touch.startY;
if( deltaX > touch.threshold && Math.abs( deltaX ) > Math.abs( deltaY ) ) {
touch.captured = true;
navigateLeft();
}
else if( deltaX < -touch.threshold && Math.abs( deltaX ) > Math.abs( deltaY ) ) {
touch.captured = true;
navigateRight();
}
else if( deltaY > touch.threshold ) {
touch.captured = true;
navigateUp();
}
else if( deltaY < -touch.threshold ) {
touch.captured = true;
navigateDown();
}
// If we're embedded, only block touch events if they have
// triggered an action
if( config.embedded ) {
if( touch.captured || isVerticalSlide( currentSlide ) ) {
event.preventDefault();
}
}
// Not embedded? Block them all to avoid needless tossing
// around of the viewport in iOS
else {
event.preventDefault();
}
}
}
// There's a bug with swiping on some Android devices unless
// the default action is always prevented
else if( UA.match( /android/gi ) ) {
event.preventDefault();
}
}
/**
* Handler for the 'touchend' event.
*/
function onTouchEnd( event ) {
touch.captured = false;
}
/**
* Convert pointer down to touch start.
*/
function onPointerDown( event ) {
if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" ) {
event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
onTouchStart( event );
}
}
/**
* Convert pointer move to touch move.
*/
function onPointerMove( event ) {
if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" ) {
event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
onTouchMove( event );
}
}
/**
* Convert pointer up to touch end.
*/
function onPointerUp( event ) {
if( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === "touch" ) {
event.touches = [{ clientX: event.clientX, clientY: event.clientY }];
onTouchEnd( event );
}
}
/**
* Handles mouse wheel scrolling, throttled to avoid skipping
* multiple slides.
*/
function onDocumentMouseScroll( event ) {
if( Date.now() - lastMouseWheelStep > 600 ) {
lastMouseWheelStep = Date.now();
var delta = event.detail || -event.wheelDelta;
if( delta > 0 ) {
navigateNext();
}
else {
navigatePrev();
}
}
}
/**
* Clicking on the progress bar results in a navigation to the
* closest approximate horizontal slide using this equation:
*
* ( clickX / presentationWidth ) * numberOfSlides
*/
function onProgressClicked( event ) {
onUserInput( event );
event.preventDefault();
var slidesTotal = toArray( dom.wrapper.querySelectorAll( HORIZONTAL_SLIDES_SELECTOR ) ).length;
var slideIndex = Math.floor( ( event.clientX / dom.wrapper.offsetWidth ) * slidesTotal );
if( config.rtl ) {
slideIndex = slidesTotal - slideIndex;
}
slide( slideIndex );
}
/**
* Event handler for navigation control buttons.
*/
function onNavigateLeftClicked( event ) { event.preventDefault(); onUserInput(); navigateLeft(); }
function onNavigateRightClicked( event ) { event.preventDefault(); onUserInput(); navigateRight(); }
function onNavigateUpClicked( event ) { event.preventDefault(); onUserInput(); navigateUp(); }
function onNavigateDownClicked( event ) { event.preventDefault(); onUserInput(); navigateDown(); }
function onNavigatePrevClicked( event ) { event.preventDefault(); onUserInput(); navigatePrev(); }
function onNavigateNextClicked( event ) { event.preventDefault(); onUserInput(); navigateNext(); }
/**
* Handler for the window level 'hashchange' event.
*/
function onWindowHashChange( event ) {
readURL();
}
/**
* Handler for the window level 'resize' event.
*/
function onWindowResize( event ) {
layout();
}
/**
* Handle for the window level 'visibilitychange' event.
*/
function onPageVisibilityChange( event ) {
var isHidden = document.webkitHidden ||
document.msHidden ||
document.hidden;
// If, after clicking a link or similar and we're coming back,
// focus the document.body to ensure we can use keyboard shortcuts
if( isHidden === false && document.activeElement !== document.body ) {
// Not all elements support .blur() - SVGs among them.
if( typeof document.activeElement.blur === 'function' ) {
document.activeElement.blur();
}
document.body.focus();
}
}
/**
* Invoked when a slide is and we're in the overview.
*/
function onOverviewSlideClicked( event ) {
// TODO There's a bug here where the event listeners are not
// removed after deactivating the overview.
if( eventsAreBound && isOverview() ) {
event.preventDefault();
var element = event.target;
while( element && !element.nodeName.match( /section/gi ) ) {
element = element.parentNode;
}
if( element && !element.classList.contains( 'disabled' ) ) {
deactivateOverview();
if( element.nodeName.match( /section/gi ) ) {
var h = parseInt( element.getAttribute( 'data-index-h' ), 10 ),
v = parseInt( element.getAttribute( 'data-index-v' ), 10 );
slide( h, v );
}
}
}
}
/**
* Handles clicks on links that are set to preview in the
* iframe overlay.
*/
function onPreviewLinkClicked( event ) {
if( event.currentTarget && event.currentTarget.hasAttribute( 'href' ) ) {
var url = event.currentTarget.getAttribute( 'href' );
if( url ) {
showPreview( url );
event.preventDefault();
}
}
}
/**
* Handles click on the auto-sliding controls element.
*/
function onAutoSlidePlayerClick( event ) {
// Replay
if( Reveal.isLastSlide() && config.loop === false ) {
slide( 0, 0 );
resumeAutoSlide();
}
// Resume
else if( autoSlidePaused ) {
resumeAutoSlide();
}
// Pause
else {
pauseAutoSlide();
}
}
// --------------------------------------------------------------------//
// ------------------------ PLAYBACK COMPONENT ------------------------//
// --------------------------------------------------------------------//
/**
* Constructor for the playback component, which displays
* play/pause/progress controls.
*
* @param {HTMLElement} container The component will append
* itself to this
* @param {Function} progressCheck A method which will be
* called frequently to get the current progress on a range
* of 0-1
*/
function Playback( container, progressCheck ) {
// Cosmetics
this.diameter = 100;
this.diameter2 = this.diameter/2;
this.thickness = 6;
// Flags if we are currently playing
this.playing = false;
// Current progress on a 0-1 range
this.progress = 0;
// Used to loop the animation smoothly
this.progressOffset = 1;
this.container = container;
this.progressCheck = progressCheck;
this.canvas = document.createElement( 'canvas' );
this.canvas.className = 'playback';
this.canvas.width = this.diameter;
this.canvas.height = this.diameter;
this.canvas.style.width = this.diameter2 + 'px';
this.canvas.style.height = this.diameter2 + 'px';
this.context = this.canvas.getContext( '2d' );
this.container.appendChild( this.canvas );
this.render();
}
Playback.prototype.setPlaying = function( value ) {
var wasPlaying = this.playing;
this.playing = value;
// Start repainting if we weren't already
if( !wasPlaying && this.playing ) {
this.animate();
}
else {
this.render();
}
};
Playback.prototype.animate = function() {
var progressBefore = this.progress;
this.progress = this.progressCheck();
// When we loop, offset the progress so that it eases
// smoothly rather than immediately resetting
if( progressBefore > 0.8 && this.progress < 0.2 ) {
this.progressOffset = this.progress;
}
this.render();
if( this.playing ) {
features.requestAnimationFrameMethod.call( window, this.animate.bind( this ) );
}
};
/**
* Renders the current progress and playback state.
*/
Playback.prototype.render = function() {
var progress = this.playing ? this.progress : 0,
radius = ( this.diameter2 ) - this.thickness,
x = this.diameter2,
y = this.diameter2,
iconSize = 28;
// Ease towards 1
this.progressOffset += ( 1 - this.progressOffset ) * 0.1;
var endAngle = ( - Math.PI / 2 ) + ( progress * ( Math.PI * 2 ) );
var startAngle = ( - Math.PI / 2 ) + ( this.progressOffset * ( Math.PI * 2 ) );
this.context.save();
this.context.clearRect( 0, 0, this.diameter, this.diameter );
// Solid background color
this.context.beginPath();
this.context.arc( x, y, radius + 4, 0, Math.PI * 2, false );
this.context.fillStyle = 'rgba( 0, 0, 0, 0.4 )';
this.context.fill();
// Draw progress track
this.context.beginPath();
this.context.arc( x, y, radius, 0, Math.PI * 2, false );
this.context.lineWidth = this.thickness;
this.context.strokeStyle = '#666';
this.context.stroke();
if( this.playing ) {
// Draw progress on top of track
this.context.beginPath();
this.context.arc( x, y, radius, startAngle, endAngle, false );
this.context.lineWidth = this.thickness;
this.context.strokeStyle = '#fff';
this.context.stroke();
}
this.context.translate( x - ( iconSize / 2 ), y - ( iconSize / 2 ) );
// Draw play/pause icons
if( this.playing ) {
this.context.fillStyle = '#fff';
this.context.fillRect( 0, 0, iconSize / 2 - 4, iconSize );
this.context.fillRect( iconSize / 2 + 4, 0, iconSize / 2 - 4, iconSize );
}
else {
this.context.beginPath();
this.context.translate( 4, 0 );
this.context.moveTo( 0, 0 );
this.context.lineTo( iconSize - 4, iconSize / 2 );
this.context.lineTo( 0, iconSize );
this.context.fillStyle = '#fff';
this.context.fill();
}
this.context.restore();
};
Playback.prototype.on = function( type, listener ) {
this.canvas.addEventListener( type, listener, false );
};
Playback.prototype.off = function( type, listener ) {
this.canvas.removeEventListener( type, listener, false );
};
Playback.prototype.destroy = function() {
this.playing = false;
if( this.canvas.parentNode ) {
this.container.removeChild( this.canvas );
}
};
// --------------------------------------------------------------------//
// ------------------------------- API --------------------------------//
// --------------------------------------------------------------------//
Reveal = {
VERSION: VERSION,
initialize: initialize,
configure: configure,
sync: sync,
// Navigation methods
slide: slide,
left: navigateLeft,
right: navigateRight,
up: navigateUp,
down: navigateDown,
prev: navigatePrev,
next: navigateNext,
// Fragment methods
navigateFragment: navigateFragment,
prevFragment: previousFragment,
nextFragment: nextFragment,
// Deprecated aliases
navigateTo: slide,
navigateLeft: navigateLeft,
navigateRight: navigateRight,
navigateUp: navigateUp,
navigateDown: navigateDown,
navigatePrev: navigatePrev,
navigateNext: navigateNext,
// Forces an update in slide layout
layout: layout,
// Randomizes the order of slides
shuffle: shuffle,
// Returns an object with the available routes as booleans (left/right/top/bottom)
availableRoutes: availableRoutes,
// Returns an object with the available fragments as booleans (prev/next)
availableFragments: availableFragments,
// Toggles the overview mode on/off
toggleOverview: toggleOverview,
// Toggles the "black screen" mode on/off
togglePause: togglePause,
// Toggles the auto slide mode on/off
toggleAutoSlide: toggleAutoSlide,
// State checks
isOverview: isOverview,
isPaused: isPaused,
isAutoSliding: isAutoSliding,
// Adds or removes all internal event listeners (such as keyboard)
addEventListeners: addEventListeners,
removeEventListeners: removeEventListeners,
// Facility for persisting and restoring the presentation state
getState: getState,
setState: setState,
// Presentation progress on range of 0-1
getProgress: getProgress,
// Returns the indices of the current, or specified, slide
getIndices: getIndices,
getTotalSlides: getTotalSlides,
// Returns the slide element at the specified index
getSlide: getSlide,
// Returns the slide background element at the specified index
getSlideBackground: getSlideBackground,
// Returns the speaker notes string for a slide, or null
getSlideNotes: getSlideNotes,
// Returns the previous slide element, may be null
getPreviousSlide: function() {
return previousSlide;
},
// Returns the current slide element
getCurrentSlide: function() {
return currentSlide;
},
// Returns the current scale of the presentation content
getScale: function() {
return scale;
},
// Returns the current configuration object
getConfig: function() {
return config;
},
// Helper method, retrieves query string as a key/value hash
getQueryHash: function() {
var query = {};
location.search.replace( /[A-Z0-9]+?=([\w\.%-]*)/gi, function(a) {
query[ a.split( '=' ).shift() ] = a.split( '=' ).pop();
} );
// Basic deserialization
for( var i in query ) {
var value = query[ i ];
query[ i ] = deserialize( unescape( value ) );
}
return query;
},
// Returns true if we're currently on the first slide
isFirstSlide: function() {
return ( indexh === 0 && indexv === 0 );
},
// Returns true if we're currently on the last slide
isLastSlide: function() {
if( currentSlide ) {
// Does this slide has next a sibling?
if( currentSlide.nextElementSibling ) return false;
// If it's vertical, does its parent have a next sibling?
if( isVerticalSlide( currentSlide ) && currentSlide.parentNode.nextElementSibling ) return false;
return true;
}
return false;
},
// Checks if reveal.js has been loaded and is ready for use
isReady: function() {
return loaded;
},
// Forward event binding to the reveal DOM element
addEventListener: function( type, listener, useCapture ) {
if( 'addEventListener' in window ) {
( dom.wrapper || document.querySelector( '.reveal' ) ).addEventListener( type, listener, useCapture );
}
},
removeEventListener: function( type, listener, useCapture ) {
if( 'addEventListener' in window ) {
( dom.wrapper || document.querySelector( '.reveal' ) ).removeEventListener( type, listener, useCapture );
}
},
// Programatically triggers a keyboard event
triggerKey: function( keyCode ) {
onDocumentKeyDown( { keyCode: keyCode } );
},
// Registers a new shortcut to include in the help overlay
registerKeyboardShortcut: function( key, value ) {
keyboardShortcuts[key] = value;
}
};
return Reveal;
}));
|
apache-2.0
|
KarlGong/ptest
|
ptest/assertion.py
|
35592
|
import re
import time
from datetime import datetime, date
from numbers import Number
from typing import Any, List, Set, Union, Iterable, Callable, Tuple, Dict, Type
# -------------------------------------------
# ------------ simple assertion -------------
# -------------------------------------------
def assert_true(actual: Any, msg: str = ""):
if actual is not True:
__raise_error(msg, f"Expected: <True>, Actual: <{actual}>.")
def assert_false(actual: Any, msg: str = ""):
if actual is not False:
__raise_error(msg, f"Expected: <False>, Actual: <{actual}>.")
def assert_none(actual: Any, msg: str = ""):
if actual is not None:
__raise_error(msg, f"Expected: <None>, Actual: <{actual}>.")
def assert_not_none(actual: Any, msg: str = ""):
if actual is None:
__raise_error(msg, f"Expected: NOT <None>, Actual: <None>.")
def assert_equals(actual: Any, expected: Any, msg: str = ""):
if not actual == expected:
__raise_error(msg, f"Expected: <{expected}>, Actual: <{actual}>.")
def assert_not_equals(actual: Any, not_expected: Any, msg: str = ""):
if actual == not_expected:
__raise_error(msg, f"Expected: NOT <{not_expected}>, Actual: <{actual}>.")
def assert_list_equals(actual_list: List, expected_list: List, msg: str = ""):
if len(actual_list) != len(expected_list):
__raise_error(msg, f"size of expected list <{expected_list}> is: <{len(expected_list)}>, but size of actual list <{actual_list}> is: <{len(actual_list)}>.")
for i, element in enumerate(actual_list):
if not element == expected_list[i]:
__raise_error(msg, f"element <index: {i}> of expected list <{expected_list}> is: <{expected_list[i]}>, but element <index: {i}> of actual list <{actual_list}> is: <{actual_list[i]}>")
def assert_list_elements_equal(actual_list: List, expected_list: List, msg: str = ""):
diff_elements = [element for element in actual_list if not element in expected_list]
if len(diff_elements) != 0:
__raise_error(msg, f"expected list <{expected_list}> doesn't contain elements <{diff_elements}> from actual list <{actual_list}>.")
diff_elements = [element for element in expected_list if not element in actual_list]
if len(diff_elements) != 0:
__raise_error(msg, f"actual list <{actual_list}> doesn't contain elements <{diff_elements}> from expected list <{expected_list}>.")
def assert_set_contains(superset: Set, subset: Set, msg: str = ""):
diff_elements = [element for element in subset if not element in superset]
if len(diff_elements) != 0:
__raise_error(msg, f"Superset <{superset}> doesn't contain elements <{diff_elements}> from subset <{subset}>.")
def fail(msg: str = ""):
__raise_error("", msg)
def __raise_error(msg: str, error_msg: str):
if msg:
raise_msg = f"{msg}\n{error_msg}"
else:
raise_msg = error_msg
raise AssertionError(raise_msg)
# -------------------------------------------
# --------- "assert that" assertion ---------
# -------------------------------------------
SUBJECT_TYPE_MAP = {}
AllSubjects = Union["_Subject", "_ObjSubject", "_NoneSubject", "_StringSubject", "_BoolSubject", "_NumericSubject", "_ListOrTupleSubject",
"_SetSubject", "_DictSubject", "_DateTimeSubject", "_DateSubject", "_CallableSubject"]
IterableSubjects = Union["_Subject", "_ObjSubject", "_IterableSubject", "_StringSubject", "_ListOrTupleSubject", "_SetSubject",
"_DictSubject"]
def assert_that(subject: Any) -> AllSubjects:
if subject is None:
return _NoneSubject(subject)
if isinstance(subject, str):
return _StringSubject(subject)
if isinstance(subject, bool):
return _BoolSubject(subject)
if isinstance(subject, Number):
return _NumericSubject(subject)
if isinstance(subject, (list, tuple)):
return _ListOrTupleSubject(subject)
if isinstance(subject, set):
return _SetSubject(subject)
if isinstance(subject, dict):
return _DictSubject(subject)
if isinstance(subject, datetime):
return _DateTimeSubject(subject)
if isinstance(subject, date):
return _DateSubject(subject)
if callable(subject):
return _CallableSubject(subject)
for subject_type, subject_class in SUBJECT_TYPE_MAP.items():
if isinstance(subject, subject_type):
return subject_class(subject)
return _ObjSubject(subject)
# this method is used to format the elements
def _format_elements(elements: Union[List, Tuple]) -> str:
return f"<{str(elements)[1:-1]}>"
# this method is used to format the obj
def _format(obj: Any) -> str:
return f"{type(obj).__name__} <{obj}>"
class _Subject(object):
def __init__(self, subject):
self._subject = subject
self._subject_name = None
self._msg = None
def named(self, name: str) -> AllSubjects:
"""
Give a name to this subject.
"""
self._subject_name = str(name)
return self
def with_message(self, message: str) -> AllSubjects:
"""
Set custom message for this assertion.
"""
self._msg = str(message)
return self
def _raise_error(self, error_msg: str, error: Type[Exception] = AssertionError):
if self._msg:
error_msg = f"{self._msg}\n{error_msg}"
raise error(error_msg)
def __str__(self):
if self._subject_name is None:
return _format(self._subject)
else:
return f"{_format(self._subject)} named \"{self._subject_name}\""
class _ObjSubject(_Subject):
def __init__(self, subject):
_Subject.__init__(self, subject)
def is_instance_of(self, class_or_type_or_tuple) -> AllSubjects:
"""
Fails unless this subject is an instance of given class or type or tuple of types.
Assert whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
The form using a tuple, is_instance_of(x, (A, B, ...)), is a shortcut for
is_instance_of(x, A) or is_instance_of(x, B) or ... (etc.).
"""
if not isinstance(self._subject, class_or_type_or_tuple):
self._raise_error(f"Unexpectedly that {self} is not instance of {_format_elements(class_or_type_or_tuple)}.")
return self
def is_type_of(self, type_) -> AllSubjects:
"""
Fails unless this subject is of given type.
"""
if type(self._subject) is not type_:
self._raise_error(f"Unexpectedly that {self} is not type of <{type_}>.")
return self
def is_equal_to(self, other_obj: Any) -> AllSubjects:
"""
Fails unless this subject is equal to other obj.
"""
if not self._subject == other_obj:
self._raise_error(f"Unexpectedly that {self} is not equal to {_format(other_obj)}.")
return self
def is_not_equal_to(self, other_obj: Any) -> AllSubjects:
"""
Fails unless this subject is not equal to other obj.
"""
if self._subject == other_obj:
self._raise_error(f"Unexpectedly that {self} is equal to {_format(other_obj)}.")
return self
def is_same_as(self, other_obj: Any) -> AllSubjects:
"""
Fails unless this subject is identical to other obj.
"""
if self._subject is not other_obj:
self._raise_error(f"Unexpectedly that {self} is not identical to {_format(other_obj)}.")
return self
def is_not_same_as(self, other_obj: Any) -> AllSubjects:
"""
Fails unless this subject is not identical to other obj.
"""
if self._subject is other_obj:
self._raise_error(f"Unexpectedly that {self} is identical to {_format(other_obj)}.")
return self
def is_none(self: Any) -> AllSubjects:
"""
Fails unless this subject is None.
"""
if self._subject is not None:
self._raise_error(f"Unexpectedly that {self} is not <None>.")
return self
def is_not_none(self: Any) -> AllSubjects:
"""
Fails unless this subject is not None.
"""
if self._subject is None:
self._raise_error(f"Unexpectedly that {self} is <None>.")
return self
def is_in(self, iterable: Iterable) -> AllSubjects:
"""
Fails unless this subject is equal to one element in the given iterable.
"""
if self._subject not in iterable:
self._raise_error(f"Unexpectedly that {self} is not in {_format(iterable)}.")
return self
def is_not_in(self, iterable: Iterable) -> AllSubjects:
"""
Fails unless this subject is not equal to any element in the given iterable.
"""
if self._subject in iterable:
self._raise_error(f"Unexpectedly that {self} is in {_format(iterable)}.")
return self
def meets(self, func: Callable[[Any], Any]) -> AllSubjects:
"""
Fails unless this subject meets the given function.
Note: The function must accepts one argument.
For Example:
assert_that(99).meets(lambda x: x > 0)
def is_positive(num):
return num > 0
assert_that(99).meets(is_positive)
"""
if not func(self._subject):
self._raise_error(f"Unexpectedly that {self} doesn't meet function <{func.__name__}>.")
return self
def attr(self, attribute_name: str) -> AllSubjects:
"""
Assert the attribute of this subject. If the attribute does not exist, raise AttributeError.
"""
if not hasattr(self._subject, attribute_name):
self._raise_error(f"Unexpectedly that {self} doesn't have attribute <{attribute_name}>.", error=AttributeError)
return assert_that(getattr(self._subject, attribute_name))
def has_attr(self, attribute_name: str) -> AllSubjects:
"""
Fails unless this subject has the given attribute.
"""
if not hasattr(self._subject, attribute_name):
self._raise_error(f"Unexpectedly that {self} doesn't have attribute <{attribute_name}>.")
return self
def does_not_have_attr(self, attribute_name: str) -> AllSubjects:
"""
Fails unless this subject doesn't have the given attribute.
"""
if hasattr(self._subject, attribute_name):
self._raise_error(f"Unexpectedly that {self} has attribute <{attribute_name}>.")
return self
def __getattr__(self, item):
self._raise_error(f"Cannot perform assertion \"{item}\" for {self}.", error=AttributeError)
class _NoneSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
class _BoolSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
def is_true(self) -> "_BoolSubject":
"""
Fails unless this subject is true.
"""
if self._subject is not True:
self._raise_error(f"Unexpectedly that {self} is not <True>.")
return self
def is_false(self) -> "_BoolSubject":
"""
Fails unless this subject is false.
"""
if self._subject is not False:
self._raise_error(f"Unexpectedly that {self} is not <False>.")
return self
class _NumericSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
def is_less_than(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is less than other number.
"""
if self._subject >= other_number:
self._raise_error(f"Unexpectedly that {self} is not less than {_format(other_number)}.")
return self
def is_greater_than(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is greater than other number.
"""
if self._subject <= other_number:
self._raise_error(f"Unexpectedly that {self} is not greater than {_format(other_number)}.")
return self
def is_less_than_or_equal_to(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is less than or equal to other number.
"""
if self._subject > other_number:
self._raise_error(f"Unexpectedly that {self} is greater than {_format(other_number)}.")
return self
def is_at_most(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is less than or equal to other number.
"""
return self.is_less_than_or_equal_to(other_number)
def is_greater_than_or_equal_to(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is greater than or equal to other number.
"""
if self._subject < other_number:
self._raise_error(f"Unexpectedly that {self} is less than {_format(other_number)}.")
return self
def is_at_least(self, other_number: Number) -> "_NumericSubject":
"""
Fails unless this subject is greater than or equal to other number.
"""
return self.is_greater_than_or_equal_to(other_number)
def is_zero(self) -> "_NumericSubject":
"""
Fails unless this subject is zero (0).
"""
if self._subject != 0:
self._raise_error(f"Unexpectedly that {self} is not <0>.")
return self
def is_not_zero(self) -> "_NumericSubject":
"""
Fails unless this subject is not zero (0).
"""
if self._subject == 0:
self._raise_error(f"Unexpectedly that {self} is <0>.")
return self
def is_positive(self) -> "_NumericSubject":
"""
Fails unless this subject is positive.
"""
if self._subject <= 0:
self._raise_error(f"Unexpectedly that {self} is not positive.")
return self
def is_negative(self) -> "_NumericSubject":
"""
Fails unless this subject is negative.
"""
if self._subject >= 0:
self._raise_error(f"Unexpectedly that {self} is not negative.")
return self
def is_between(self, low: Number, high: Number) -> "_NumericSubject":
"""
Fails unless this subject is between low and high.
Note: low and high are included
"""
if self._subject < low or self._subject > high:
self._raise_error(f"Unexpectedly that {self} is not between low {_format(low)} and high {_format(high)}.")
return self
class _IterableSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
def is_empty(self) -> IterableSubjects:
"""
Fails unless this subject is empty.
"""
if len(self._subject) != 0:
self._raise_error(f"Unexpectedly that {self} is not empty.")
return self
def is_not_empty(self) -> IterableSubjects:
"""
Fails unless this subject is not empty.
"""
if len(self._subject) == 0:
self._raise_error(f"Unexpectedly that {self} is empty.")
return self
def has_length(self, expected_length: int) -> IterableSubjects:
"""
Fails unless this subject has the given length.
"""
if not len(self._subject) == expected_length:
self._raise_error(f"Unexpectedly that {self} doesn't have a length of <{expected_length}>. It is <{len(self._subject)}>.")
return self
def contains(self, obj: Any) -> IterableSubjects:
"""
Fails unless this subject contains the given object.
"""
if obj not in self._subject:
self._raise_error(f"Unexpectedly that {self} doesn't contain {_format(obj)}.")
return self
def does_not_contain(self, obj: Any) -> IterableSubjects:
"""
Fails unless this subject doesn't contain the given object.
"""
if obj in self._subject:
self._raise_error(f"Unexpectedly that {self} contains {_format(obj)}.")
return self
def contains_all_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless this subject contains all the elements in the given iterable.
"""
uncontained_objs = [obj for obj in iterable if obj not in self._subject]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} doesn't contain elements {_format_elements(uncontained_objs)} in {_format(iterable)}.")
return self
def is_all_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless all the elements in this subject are in the given iterable.
"""
uncontained_objs = [obj for obj in self._subject if obj not in iterable]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} has elements {_format_elements(uncontained_objs)} not in {_format(iterable)}.")
return self
def contains_any_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless this subject contains any element in the given iterable.
"""
contained_objs = [obj for obj in iterable if obj in self._subject]
if not contained_objs:
self._raise_error(f"Unexpectedly that {self} doesn't contain any element in {_format(iterable)}.")
return self
def is_any_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless any element in this subject is in given iterable.
"""
contained_objs = [obj for obj in self._subject if obj in iterable]
if not contained_objs:
self._raise_error(f"Unexpectedly that {self} doesn't have any element in {_format(iterable)}.")
return self
def contains_none_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless this subject doesn't contain any element in the given iterable.
"""
contained_objs = [obj for obj in iterable if obj in self._subject]
if contained_objs:
self._raise_error(f"Unexpectedly that {self} contains elements {_format_elements(contained_objs)} in {_format(iterable)}.")
return self
def is_none_in(self, iterable: Iterable) -> IterableSubjects:
"""
Fails unless any element in this subject is not in the given iterable.
"""
contained_objs = [obj for obj in self._subject if obj in iterable]
if contained_objs:
self._raise_error(f"Unexpectedly that {self} has elements {_format_elements(contained_objs)} in {_format(iterable)}.")
return self
def length(self) -> "_NumericSubject":
"""
Assert the length of this subject.
"""
return _NumericSubject(len(self._subject))
def each(self) -> AllSubjects:
"""
For each obj in this subject.
"""
return _IterableEachSubject(self._subject)
class _IterableEachSubject(object):
def __init__(self, iterable_subject):
self._iterable_subject = iterable_subject
def __getattr__(self, item):
if item in ["length", "index", "key", "attr"]:
def each_attr(*args, **kwargs):
iterable_subject = []
for subject in self._iterable_subject:
iterable_subject.append(getattr(assert_that(subject), item)(*args, **kwargs)._subject)
return _IterableEachSubject(iterable_subject)
return each_attr
elif item in ["each", "each_key", "each_value"]:
def each_each(*args, **kwargs):
iterable_subject = []
for iterable in self._iterable_subject:
for subject in getattr(assert_that(iterable), item)(*args, **kwargs)._iterable_subject:
iterable_subject.append(subject)
return _IterableEachSubject(iterable_subject)
return each_each
else:
def assert_each(*args, **kwargs):
for subject in self._iterable_subject:
getattr(assert_that(subject), item)(*args, **kwargs)
return self
return assert_each
class _StringSubject(_IterableSubject):
def __init__(self, subject):
_IterableSubject.__init__(self, subject)
def is_equal_to_ignoring_case(self, string: str) -> "_StringSubject":
"""
Fails unless this string is equal to other string ignoring case.
"""
if not self._subject.lower() == string.lower():
self._raise_error(f"Unexpectedly that {self} is not equal to {_format(string)} ignoring case.")
return self
def is_blank(self) -> "_StringSubject":
"""
Fails unless this string is blank.
"""
if len(self._subject.strip()) != 0:
self._raise_error(f"Unexpectedly that {self} is not blank.")
return self
def is_not_blank(self) -> "_StringSubject":
"""
Fails unless this string is not blank.
"""
if len(self._subject.strip()) == 0:
self._raise_error(f"Unexpectedly that {self} is blank.")
return self
def starts_with(self, prefix: str) -> "_StringSubject":
"""
Fails unless this string starts with the given string.
"""
if not self._subject.startswith(prefix):
self._raise_error(f"Unexpectedly that {self} doesn't start with {_format(prefix)}.")
return self
def ends_with(self, suffix: str) -> "_StringSubject":
"""
Fails unless this string ends with the given string.
"""
if not self._subject.endswith(suffix):
self._raise_error(f"Unexpectedly that {self} doesn't end with {_format(suffix)}.")
return self
def matches(self, regex: str) -> "_StringSubject":
"""
Fails unless this string matches the given regex.
Note: If you want to match the entire string, just include anchors in the regex pattern.
"""
if not re.compile(regex).search(self._subject):
self._raise_error(f"Unexpectedly that {self} doesn't match regex <{regex}>.")
return self
def does_not_match(self, regex: str) -> "_StringSubject":
"""
Fails unless this string doesn't match the given regex.
Note: If you want to match the entire string, just include anchors in the regex pattern.
"""
if re.compile(regex).search(self._subject):
self._raise_error(f"Unexpectedly that {self} matches regex <{regex}>.")
return self
def is_alpha(self) -> "_StringSubject":
"""
Fails unless this string contains only alphabetic chars.
"""
if not self._subject.isalpha():
self._raise_error(f"Unexpectedly that {self} doesn't contain only alphabetic chars.")
return self
def is_digit(self) -> "_StringSubject":
"""
Fails unless this string contains only digits.
"""
if not self._subject.isdigit():
self._raise_error(f"Unexpectedly that {self} doesn't contain only digits.")
return self
def is_lower(self) -> "_StringSubject":
"""
Fails unless this string contains only lowercase chars.
"""
if not self._subject == self._subject.lower():
self._raise_error(f"Unexpectedly that {self} doesn't contain only lowercase chars.")
return self
def is_upper(self) -> "_StringSubject":
"""
Fails unless this string contains only uppercase chars.
"""
if not self._subject == self._subject.upper():
self._raise_error(f"Unexpectedly that {self} doesn't contain only uppercase chars.")
return self
class _ListOrTupleSubject(_IterableSubject):
def __init__(self, subject):
_IterableSubject.__init__(self, subject)
def has_same_elements_as(self, other_list_or_tuple: Union[List, Tuple]) -> "_ListOrTupleSubject":
"""
Fails unless this list/tuple has the same elements as other list/tuple.
"""
uncontained_objs = [obj for obj in other_list_or_tuple if obj not in self._subject]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} doesn't contain elements {_format_elements(uncontained_objs)} in {_format(other_list_or_tuple)}.")
uncontained_objs = [obj for obj in self._subject if obj not in other_list_or_tuple]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} contains elements {_format_elements(uncontained_objs)} not in {_format(other_list_or_tuple)}.")
return self
def contains_duplicates(self) -> "_ListOrTupleSubject":
"""
Fails unless this list/tuple contains duplicate elements.
"""
if len(self._subject) == len(set(self._subject)):
self._raise_error(f"Unexpectedly that {self} doesn't contain duplicate elements.")
return self
def does_not_contain_duplicates(self) -> "_ListOrTupleSubject":
"""
Fails unless this list/tuple doesn't contain duplicate elements.
"""
element_counter = {}
for element in self._subject:
if element in element_counter:
element_counter[element] += 1
else:
element_counter[element] = 1
duplicates = [element for element, count in element_counter.items() if count > 1]
if duplicates:
self._raise_error(f"Unexpectedly that {self} contains duplicate elements {_format_elements(duplicates)}.")
return self
def index(self, index: int) -> AllSubjects:
"""
Assert the obj of this list/tuple by index. If index doesn't exist, raise IndexError.
"""
if index >= len(self._subject) or index < 0:
self._raise_error(f"Unexpectedly that {self} has no object of index <{index}>.", error=IndexError)
return assert_that(self._subject[index])
class _SetSubject(_IterableSubject):
def __init__(self, subject):
_IterableSubject.__init__(self, subject)
def is_super_of(self, other_set: Set) -> "_SetSubject":
"""
Fails unless this set is a superset of other set.
"""
uncontained_objs = [obj for obj in other_set if obj not in self._subject]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} doesn't contain elements {_format_elements(uncontained_objs)} in {_format(other_set)}.")
return self
def is_sub_of(self, other_set: Set) -> "_SetSubject":
"""
Fails unless this set is a subset of other set.
"""
uncontained_objs = [obj for obj in self._subject if obj not in other_set]
if uncontained_objs:
self._raise_error(f"Unexpectedly that {self} contains elements {_format_elements(uncontained_objs)} not in {_format(other_set)}.")
return self
class _DictSubject(_IterableSubject):
def __init__(self, subject):
_IterableSubject.__init__(self, subject)
def contains_key(self, key: Any) -> "_DictSubject":
"""
Fails unless this dict contains the given key.
"""
if key not in self._subject:
self._raise_error(f"Unexpectedly that {self} doesn't contain key {_format(key)}.")
return self
def does_not_contain_key(self, key: Any) -> "_DictSubject":
"""
Fails unless this dict doesn't contain the given key.
"""
if key in self._subject:
self._raise_error(f"Unexpectedly that {self} contains key {_format(key)}.")
return self
def contains_value(self, value: Any) -> "_DictSubject":
"""
Fails unless this dict contains the given value.
"""
if value not in self._subject.values():
self._raise_error(f"Unexpectedly that {self} doesn't contain value {_format(value)}.")
return self
def does_not_contain_value(self, value: Any) -> "_DictSubject":
"""
Fails unless this dict doesn't contain the given value.
"""
if value in self._subject.values():
self._raise_error(f"Unexpectedly that {self} contains value {_format(value)}.")
return self
def contains_entry(self, key: Any, value: Any) -> "_DictSubject":
"""
Fails unless this dict contains the given entry.
"""
if (key, value) not in self._subject.items():
self._raise_error(f"Unexpectedly that {self} doesn't contain entry, key: {_format(key)}, value: {_format(value)}.")
return self
def does_not_contain_entry(self, key: Any, value: Any) -> "_DictSubject":
"""
Fails unless this dict doesn't contain the given entry.
"""
if (key, value) in self._subject.items():
self._raise_error(f"Unexpectedly that {self} contains entry, key: {_format(key)}, value: {_format(value)}.")
return self
def is_super_of(self, other_dict: Dict) -> "_DictSubject":
"""
Fails unless this dict contains all the entries in other dict.
"""
uncontained_entries = [entry for entry in other_dict.items() if entry not in self._subject.items()]
if uncontained_entries:
self._raise_error(f"Unexpectedly that {self} doesn't contain entries {_format_elements(uncontained_entries)} in {_format(other_dict)}.")
return self
def is_sub_of(self, other_dict: Dict) -> "_DictSubject":
"""
Fails unless all the entries in this dict are in other dict.
"""
uncontained_entries = [entry for entry in self._subject.items() if entry not in other_dict.items()]
if uncontained_entries:
self._raise_error(f"Unexpectedly that {self} contains entries {_format_elements(uncontained_entries)} not in {_format(other_dict)}.")
return self
def key(self, key: Any) -> AllSubjects:
"""
Assert the value of this dict by key. If key doesn't exist, raise KeyError
"""
if key not in self._subject:
self._raise_error(f"Unexpectedly that {self} doesn't contain key {_format(key)}.", error=KeyError)
return assert_that(self._subject[key])
def each(self) -> "_ListOrTupleSubject":
"""
For each entry in this dict.
"""
return _IterableEachSubject(self._subject.items())
def each_key(self) -> AllSubjects:
"""
For each key in this dict.
"""
return _IterableEachSubject(self._subject.keys())
def each_value(self) -> AllSubjects:
"""
For each value in this dict.
"""
return _IterableEachSubject(self._subject.values())
class _DateSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
def is_before(self, other_date: date) -> "_DateSubject":
"""
Fails unless this date is before other date.
"""
if self._subject >= other_date:
self._raise_error(f"Unexpectedly that {self} is not before {_format(other_date)}.")
return self
def is_after(self, other_date: date) -> "_DateSubject":
"""
Fails unless this date is after other date.
"""
if self._subject <= other_date:
self._raise_error(f"Unexpectedly that {self} is not after {_format(other_date)}.")
return self
class _DateTimeSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
def is_before(self, other_datetime: datetime) -> "_DateTimeSubject":
"""
Fails unless this datetime is before other datetime.
"""
if self._subject >= other_datetime:
self._raise_error(f"Unexpectedly that {self} is not before {_format(other_datetime)}.")
return self
def is_after(self, other_datetime: datetime) -> "_DateTimeSubject":
"""
Fails unless this datetime is after other datetime.
"""
if self._subject <= other_datetime:
self._raise_error(f"Unexpectedly that {self} is not after {_format(other_datetime)}.")
return self
class _CallableSubject(_ObjSubject):
def __init__(self, subject):
_ObjSubject.__init__(self, subject)
self._args = []
self._kwargs = {}
def with_args(self, *args, **kwargs) -> "_CallableSubject":
self._args = args
self._kwargs = kwargs
return self
def raises_exception(self, exception_class: Type[Exception]):
"""
Fails unless this callable does't raise exception or raise wrong exception.
"""
try:
self._subject(*self._args, **self._kwargs)
except Exception as e:
if not issubclass(e.__class__, exception_class):
self._raise_error(f"Unexpectedly that {self} raises wrong exception <{e.__class__.__module__}.{e.__class__.__name__}>.")
else:
self._raise_error(f"Unexpectedly that {self} doesn't raise exception.")
def will(self, interval: int = 1000, timeout: int = 30000) -> AllSubjects:
"""
Failed if this callable's result doesn't match following assertions until timing out.
:param interval: interval of asserting, in milliseconds
:param timeout: timeout of asserting, in milliseconds
"""
return _CallableWillSubject(self._subject, interval, timeout, self._args, self._kwargs)
class _CallableWillSubject(object):
def __init__(self, subject, interval, timeout, args, kwargs):
self._subject = subject
self._interval = interval
self._timeout = timeout
self._args = args
self._kwargs = kwargs
def __getattr__(self, item):
if item in ["length", "index", "key", "attr", "each", "each_key", "each_value"]:
raise AttributeError(f"Cannot call \"{item}\" in callable-will assertion.")
def wrapper(*args, **kwargs):
start_time = time.time() * 1000.0
last_exception = {"value": None}
try:
getattr(assert_that(self._subject(*self._args, **self._kwargs)), item)(*args, **kwargs)
except AssertionError as e:
last_exception["value"] = e
else:
return self
while (time.time() * 1000.0 - start_time) <= self._timeout:
time.sleep(self._interval / 1000.0)
try:
getattr(assert_that(self._subject(*self._args, **self._kwargs)), item)(*args, **kwargs)
except AssertionError as e:
last_exception["value"] = e
else:
return self
raise AssertionError(f"Callable's result doesn't match expected until timing out, last assertion error is:\n{last_exception['value']}")
return wrapper
|
apache-2.0
|
andresriancho/moto
|
tests/test_ec2/test_subnets.py
|
1076
|
import boto
from boto.exception import EC2ResponseError
import sure # noqa
from moto import mock_ec2
@mock_ec2
def test_subnets():
conn = boto.connect_vpc('the_key', 'the_secret')
vpc = conn.create_vpc("10.0.0.0/16")
subnet = conn.create_subnet(vpc.id, "10.0.0.0/18")
all_subnets = conn.get_all_subnets()
all_subnets.should.have.length_of(1)
conn.delete_subnet(subnet.id)
all_subnets = conn.get_all_subnets()
all_subnets.should.have.length_of(0)
conn.delete_subnet.when.called_with(
subnet.id).should.throw(EC2ResponseError)
@mock_ec2
def test_subnet_tagging():
conn = boto.connect_vpc('the_key', 'the_secret')
vpc = conn.create_vpc("10.0.0.0/16")
subnet = conn.create_subnet(vpc.id, "10.0.0.0/18")
subnet.add_tag("a key", "some value")
tag = conn.get_all_tags()[0]
tag.name.should.equal("a key")
tag.value.should.equal("some value")
# Refresh the subnet
subnet = conn.get_all_subnets()[0]
subnet.tags.should.have.length_of(1)
subnet.tags["a key"].should.equal("some value")
|
apache-2.0
|
atata-framework/atata-webdriverextras
|
src/Atata.WebDriverExtras/Extensions/ByKindExtensions.cs
|
2677
|
using OpenQA.Selenium;
namespace Atata
{
public static class ByKindExtensions
{
public static By Button(this By by, string name = null)
{
return by.OfKind("button", name);
}
public static By Link(this By by, string name = null)
{
return by.OfKind("link", name);
}
public static By Input(this By by, string name = null)
{
return by.OfKind("input", name);
}
public static By Field(this By by, string name = null)
{
return by.OfKind("field", name);
}
public static By DropDown(this By by, string name = null)
{
return by.OfKind("drop-down", name);
}
public static By DropDownList(this By by, string name = null)
{
return by.OfKind("drop-down list", name);
}
public static By DropDownOption(this By by, string name = null)
{
return by.OfKind("drop-down option", name);
}
public static By DropDownButton(this By by, string name = null)
{
return by.OfKind("drop-down button", name);
}
public static By Table(this By by, string name = null)
{
return by.OfKind("table", name);
}
public static By TableColumn(this By by, string name = null)
{
return by.OfKind("table column", name);
}
public static By TableRow(this By by, string name = null)
{
return by.OfKind("table row", name);
}
public static By TableHeader(this By by, string name = null)
{
return by.OfKind("table header", name);
}
public static By Label(this By by, string name = null)
{
return by.OfKind("label", name);
}
public static By Popup(this By by, string name = null)
{
return by.OfKind("popup", name);
}
public static By Window(this By by, string name = null)
{
return by.OfKind("window", name);
}
public static By PopupWindow(this By by, string name = null)
{
return by.OfKind("popup window", name);
}
public static By Dialog(this By by, string name = null)
{
return by.OfKind("dialog", name);
}
public static By Menu(this By by, string name = null)
{
return by.OfKind("menu", name);
}
public static By DropDownMenu(this By by, string name = null)
{
return by.OfKind("drop-down menu", name);
}
}
}
|
apache-2.0
|
google/BIG-bench
|
bigbench/bbseqio/tools/utils.py
|
1102
|
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utils for catalog update script."""
from typing import Sequence
FILE_HEADER = """# BIG-bench SeqIO Tasks and Mixtures Catalog"""
CATALOG_FILENAME = "bigbench/bbseqio/catalog.md"
def get_file_header() -> str:
return FILE_HEADER
def get_bb_task_url(bb_task_name: str) -> str:
return f"https://github.com/google/BIG-bench/tree/main/bigbench/benchmark_tasks/{bb_task_name}/"
def write_to_catalog_file(lines: Sequence[str]) -> None:
with open(CATALOG_FILENAME, "w") as out_file:
out_file.write("\n".join(lines))
|
apache-2.0
|
TopSecretGames/game
|
src/Tests/GameControllerTest.cpp
|
491
|
#define CATCH_CONFIG_MAIN
#include "GameController.h"
#include "MoveControllerStub.h"
#include "fakeit.hpp"
using namespace fakeit;
TEST_CASE("That game event listener got notified well", "[GameController]") {
tsg::game::GameController *controller = tsg::game::GameController::getInstance();
MoveControllerStub moveControllerStub;
controller->injectControllers(&moveControllerStub, nullptr, nullptr, nullptr);
controller->init();
REQUIRE(moveControllerStub.isInitialized());
}
|
apache-2.0
|
GoogleCloudPlatform/cloud-opensource-python
|
compatibility_lib/compatibility_lib/utils.py
|
5401
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Common utils for compatibility_lib."""
from datetime import datetime
import json
import logging
import urllib.request
from compatibility_lib import compatibility_checker
from compatibility_lib import configs
DATETIME_FORMAT = "%Y-%m-%d"
PYPI_URL = 'https://pypi.org/pypi/'
class PackageNotSupportedError(Exception):
"""Package is not supported by our checker server."""
def __init__(self, package_name):
super(PackageNotSupportedError, self).__init__(
'Package {} is not supported by our checker server.'.format(
package_name))
self.package_name = package_name
def call_pypi_json_api(package_name, pkg_version=None):
if pkg_version is not None:
pypi_pkg_url = PYPI_URL + '{}/{}/json'.format(
package_name, pkg_version)
else:
pypi_pkg_url = PYPI_URL + '{}/json'.format(package_name)
try:
r = urllib.request.Request(pypi_pkg_url)
with urllib.request.urlopen(r) as f:
result = json.loads(f.read().decode('utf-8'))
except urllib.error.HTTPError:
logging.error('Package {} with version {} not found in Pypi'.
format(package_name, pkg_version))
return None
return result
def _is_package_in_whitelist(packages):
"""Return True if all the given packages are in whitelist.
Args:
packages: A list of package names.
Returns:
True if all packages are in whitelist, else False.
"""
for pkg in packages:
if pkg not in configs.PKG_LIST and pkg not in configs.WHITELIST_URLS:
return False
return True
class DependencyInfo(object):
"""Common utils of getting dependency info for a package."""
def __init__(self, py_version=None, checker=None, store=None):
if py_version is None:
py_version = '3'
if checker is None:
checker = compatibility_checker.CompatibilityChecker()
self.py_version = py_version
self.checker = checker
self.store = store
def _get_from_cloud_sql(self, package_name):
"""Gets the package dependency info from compatibility store
which gets its dependnecy info from cloud sql.
Args:
package_name: the name of the package to query
Returns:
a dict mapping from dependency package name (string) to
the info (dict)
"""
if self.store is not None:
if (package_name in configs.PKG_LIST or
package_name in configs.WHITELIST_URLS):
depinfo = self.store.get_dependency_info(package_name)
return depinfo
else:
return None
def _get_from_endpoint(self, package_name):
"""Gets the package dependency info from the compatibility checker
endpoint.
Args:
package_name: the name of the package to query (string)
Returns:
a dict mapping from dependency package name (string) to
the info (dict)
"""
_result = self.checker.get_compatibility(
python_version=self.py_version, packages=[package_name])
result = [item for item in _result]
depinfo = result[0][0].get('dependency_info')
# depinfo can be None if there is an exception during pip install or
# the package is not supported by checker server (not in whitelist).
if depinfo is None:
logging.warning(
"Could not get the dependency info of package {} from server."
.format(package_name))
raise PackageNotSupportedError(package_name)
fields = ('installed_version_time',
'current_time', 'latest_version_time')
for pkgname in depinfo.keys():
for field in fields:
depinfo[pkgname][field] = _parse_datetime(
depinfo[pkgname][field])
return depinfo
def get_dependency_info(self, package_name):
"""Gets the package dependency info
Args:
package_name: the name of the package to query (string)
Returns:
a dict mapping from dependency package name (string) to
the info (dict)
"""
depinfo = self._get_from_cloud_sql(package_name)
if depinfo is None:
depinfo = self._get_from_endpoint(package_name)
return depinfo
def _parse_datetime(date_string):
"""Converts a date string into a datetime obj
Args:
date_string: a date as a string
Returns:
the date as a datetime obj
"""
if date_string is None:
return None
date_string = date_string.replace('T', ' ')
short_date = date_string.split(' ')[0]
return datetime.strptime(short_date, DATETIME_FORMAT)
|
apache-2.0
|
facebook/fbthrift
|
thrift/compiler/test/fixtures/includes/gen-swift/test/fixtures/includes/includes/Constants.java
|
632
|
/**
* Autogenerated by Thrift
*
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
* @generated
*/
package test.fixtures.includes.includes;
import com.facebook.swift.codec.*;
import com.google.common.collect.*;
import java.util.*;
@SwiftGenerated
public final class Constants {
private Constants() {}
public static final test.fixtures.includes.includes.Included EXAMPLE_INCLUDED = new test.fixtures.includes.includes.Included.Builder().setMyIntField(2L).setMyTransitiveField(test.fixtures.includes.transitive.Constants.EXAMPLE_FOO).build();
public static final long INCLUDED_CONSTANT = 42L;
}
|
apache-2.0
|
xiaolihope/PerfKitBenchmarker-1.7.0
|
perfkitbenchmarker/virtual_machine.py
|
21484
|
# Copyright 2015 PerfKitBenchmarker Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Class to represent a Virtual Machine object.
All VM specifics are self-contained and the class provides methods to
operate on the VM: boot, shutdown, etc.
"""
import abc
import os.path
import threading
import jinja2
from perfkitbenchmarker import background_workload
from perfkitbenchmarker import data
from perfkitbenchmarker import disk
from perfkitbenchmarker import errors
from perfkitbenchmarker import flags
from perfkitbenchmarker import resource
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.configs import option_decoders
from perfkitbenchmarker.configs import spec
FLAGS = flags.FLAGS
DEFAULT_USERNAME = 'perfkit'
_VM_SPEC_REGISTRY = {}
_VM_REGISTRY = {}
flags.DEFINE_list('vm_metadata', [], 'Metadata to add to the vm '
'via the provider\'s AddMetadata function. It expects'
'key:value pairs')
def GetVmSpecClass(cloud):
"""Returns the VmSpec class corresponding to 'cloud'."""
return _VM_SPEC_REGISTRY.get(cloud, BaseVmSpec)
def GetVmClass(cloud, os_type):
"""Returns the VM class corresponding to 'cloud' and 'os_type'."""
return _VM_REGISTRY.get((cloud, os_type))
class AutoRegisterVmSpecMeta(spec.BaseSpecMetaClass):
"""Metaclass which allows VmSpecs to automatically be registered."""
def __init__(cls, name, bases, dct):
super(AutoRegisterVmSpecMeta, cls).__init__(name, bases, dct)
if cls.CLOUD in _VM_SPEC_REGISTRY:
raise Exception('BaseVmSpec subclasses must have a CLOUD attribute.')
_VM_SPEC_REGISTRY[cls.CLOUD] = cls
class AutoRegisterVmMeta(abc.ABCMeta):
"""Metaclass which allows VMs to automatically be registered."""
def __init__(cls, name, bases, dct):
if hasattr(cls, 'CLOUD') and hasattr(cls, 'OS_TYPE'):
if cls.CLOUD is None:
raise Exception('BaseVirtualMachine subclasses must have a CLOUD '
'attribute.')
elif cls.OS_TYPE is None:
raise Exception('BaseOsMixin subclasses must have an OS_TYPE '
'attribute.')
else:
_VM_REGISTRY[(cls.CLOUD, cls.OS_TYPE)] = cls
super(AutoRegisterVmMeta, cls).__init__(name, bases, dct)
class BaseVmSpec(spec.BaseSpec):
"""Storing various data about a single vm.
Attributes:
zone: The region / zone the in which to launch the VM.
machine_type: The provider-specific instance type (e.g. n1-standard-8).
image: The disk image to boot from.
install_packages: If false, no packages will be installed. This is
useful if benchmark dependencies have already been installed.
background_cpu_threads: The number of threads of background CPU usage
while running the benchmark.
background_network_mbits_per_sec: The number of megabits per second of
background network traffic during the benchmark.
background_network_ip_type: The IP address type (INTERNAL or
EXTERNAL) to use for generating background network workload.
"""
__metaclass__ = AutoRegisterVmSpecMeta
CLOUD = None
@classmethod
def _ApplyFlags(cls, config_values, flag_values):
"""Overrides config values with flag values.
Can be overridden by derived classes to add support for specific flags.
Args:
config_values: dict mapping config option names to provided values. Is
modified by this function.
flag_values: flags.FlagValues. Runtime flags that may override the
provided config values.
Returns:
dict mapping config option names to values derived from the config
values or flag values.
"""
super(BaseVmSpec, cls)._ApplyFlags(config_values, flag_values)
if flag_values['image'].present:
config_values['image'] = flag_values.image
if flag_values['install_packages'].present:
config_values['install_packages'] = flag_values.install_packages
if flag_values['machine_type'].present:
config_values['machine_type'] = flag_values.machine_type
if flag_values['background_cpu_threads'].present:
config_values['background_cpu_threads'] = (
flag_values.background_cpu_threads)
if flag_values['background_network_mbits_per_sec'].present:
config_values['background_network_mbits_per_sec'] = (
flag_values.background_network_mbits_per_sec)
if flag_values['background_network_ip_type'].present:
config_values['background_network_ip_type'] = (
flag_values.background_network_ip_type)
@classmethod
def _GetOptionDecoderConstructions(cls):
"""Gets decoder classes and constructor args for each configurable option.
Can be overridden by derived classes to add options or impose additional
requirements on existing options.
Returns:
dict. Maps option name string to a (ConfigOptionDecoder class, dict) pair.
The pair specifies a decoder class and its __init__() keyword
arguments to construct in order to decode the named option.
"""
result = super(BaseVmSpec, cls)._GetOptionDecoderConstructions()
result.update({
'image': (option_decoders.StringDecoder, {'none_ok': True,
'default': None}),
'install_packages': (option_decoders.BooleanDecoder, {'default': True}),
'machine_type': (option_decoders.StringDecoder, {'none_ok': True,
'default': None}),
'zone': (option_decoders.StringDecoder, {'none_ok': True,
'default': None}),
'background_network_mbits_per_sec': (option_decoders.IntDecoder, {
'none_ok': True, 'default': None}),
'background_network_ip_type': (option_decoders.EnumDecoder, {
'default': vm_util.IpAddressSubset.EXTERNAL,
'valid_values': [vm_util.IpAddressSubset.EXTERNAL,
vm_util.IpAddressSubset.INTERNAL]}),
'background_cpu_threads': (option_decoders.IntDecoder, {
'none_ok': True, 'default': None})})
return result
class BaseVirtualMachine(resource.BaseResource):
"""Base class for Virtual Machines.
This class holds VM methods and attributes relating to the VM as a cloud
resource. For methods and attributes that interact with the VM's guest
OS, see BaseOsMixin and its subclasses.
Attributes:
image: The disk image used to boot.
internal_ip: Internal IP address.
ip_address: Public (external) IP address.
machine_type: The provider-specific instance type (e.g. n1-standard-8).
project: The provider-specific project associated with the VM (e.g.
artisanal-lightbulb-883).
ssh_public_key: Path to SSH public key file.
ssh_private_key: Path to SSH private key file.
user_name: Account name for login. the contents of 'ssh_public_key' should
be in .ssh/authorized_keys for this user.
zone: The region / zone the VM was launched in.
disk_specs: list of BaseDiskSpec objects. Specifications for disks attached
to the VM.
scratch_disks: list of BaseDisk objects. Scratch disks attached to the VM.
max_local_disks: The number of local disks on the VM that can be used as
scratch disks or that can be striped together.
background_cpu_threads: The number of threads of background CPU usage
while running the benchmark.
background_network_mbits_per_sec: Number of mbits/sec of background network
usage while running the benchmark.
background_network_ip_type: Type of IP address to use for generating
background network workload
"""
__metaclass__ = AutoRegisterVmMeta
is_static = False
CLOUD = None
_instance_counter_lock = threading.Lock()
_instance_counter = 0
def __init__(self, vm_spec):
"""Initialize BaseVirtualMachine class.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(BaseVirtualMachine, self).__init__()
with self._instance_counter_lock:
self.instance_number = self._instance_counter
self.name = 'pkb-%s-%d' % (FLAGS.run_uri, self.instance_number)
BaseVirtualMachine._instance_counter += 1
self.zone = vm_spec.zone
self.machine_type = vm_spec.machine_type
self.image = vm_spec.image
self.install_packages = vm_spec.install_packages
self.ip_address = None
self.internal_ip = None
self.user_name = DEFAULT_USERNAME
self.password = None
self.ssh_public_key = vm_util.GetPublicKeyPath()
self.ssh_private_key = vm_util.GetPrivateKeyPath()
self.disk_specs = []
self.scratch_disks = []
self.max_local_disks = 0
self.local_disk_counter = 0
self.remote_disk_counter = 0
self.background_cpu_threads = vm_spec.background_cpu_threads
self.background_network_mbits_per_sec = (
vm_spec.background_network_mbits_per_sec)
self.background_network_ip_type = vm_spec.background_network_ip_type
self.network = None
self.firewall = None
def __repr__(self):
return '<BaseVirtualMachine [ip={0}, internal_ip={1}]>'.format(
self.ip_address, self.internal_ip)
def __str__(self):
if self.ip_address:
return self.ip_address
return super(BaseVirtualMachine, self).__str__()
def CreateScratchDisk(self, disk_spec):
"""Create a VM's scratch disk.
Args:
disk_spec: virtual_machine.BaseDiskSpec object of the disk.
"""
pass
def DeleteScratchDisks(self):
"""Delete a VM's scratch disks."""
for scratch_disk in self.scratch_disks:
if scratch_disk.disk_type != disk.LOCAL:
scratch_disk.Delete()
def GetScratchDir(self, disk_num=0):
"""Gets the path to the scratch directory.
Args:
disk_num: The number of the disk to mount.
Returns:
The mounted disk directory.
"""
if disk_num >= len(self.scratch_disks):
raise errors.Error(
'GetScratchDir(disk_num=%s) is invalid, max disk_num is %s' % (
disk_num, len(self.scratch_disks)))
return self.scratch_disks[disk_num].mount_point
def GetLocalDisks(self):
# TODO(ehankland) This method should be removed as soon as raw/unmounted
# scratch disks are supported in a different way. Only the Aerospike
# benchmark currently accesses disks using this method.
"""Returns a list of local disks on the VM."""
return []
def AllowPort(self, port):
"""Opens the port on the firewall corresponding to the VM if one exists."""
if self.firewall:
self.firewall.AllowPort(self, port)
def AllowRemoteAccessPorts(self):
"""Allow all ports in self.remote_access_ports."""
for port in self.remote_access_ports:
self.AllowPort(port)
def AddMetadata(self, **kwargs):
"""Add key/value metadata to the instance.
Adds metadata in the form of key value pairs to the instance. Useful for
debugging / introspection.
The default implementation is a noop. Cloud providers supporting instance
metadata should override.
Args:
**kwargs: dict. (tag name, tag value) pairs to set as metadata on the
instance.
"""
pass
def GetMachineTypeDict(self):
"""Returns a dict containing properties that specify the machine type.
Returns:
dict mapping string property key to value.
"""
result = {}
if self.machine_type is not None:
result['machine_type'] = self.machine_type
return result
class BaseOsMixin(object):
"""The base class for OS Mixin classes.
This class holds VM methods and attributes relating to the VM's guest OS.
For methods and attributes that relate to the VM as a cloud resource,
see BaseVirtualMachine and its subclasses.
Attributes:
bootable_time: The time when the VM finished booting.
hostname: The VM's hostname.
remote_access_ports: A list of ports which must be opened on the firewall
in order to access the VM.
"""
__metaclass__ = abc.ABCMeta
OS_TYPE = None
def __init__(self):
super(BaseOsMixin, self).__init__()
self._installed_packages = set()
self.bootable_time = None
self.hostname = None
# Ports that will be opened by benchmark_spec to permit access to the VM.
self.remote_access_ports = []
# Cached values
self._reachable = {}
self._total_memory_kb = None
self._num_cpus = None
@abc.abstractmethod
def RemoteCommand(self, command, should_log=False, ignore_failure=False,
suppress_warning=False, timeout=None, **kwargs):
"""Runs a command on the VM.
Derived classes may add additional kwargs if necessary, but they should not
be used outside of the class itself since they are non standard.
Args:
command: A valid bash command.
should_log: A boolean indicating whether the command result should be
logged at the info level. Even if it is false, the results will
still be logged at the debug level.
ignore_failure: Ignore any failure if set to true.
suppress_warning: Suppress the result logging from IssueCommand when the
return code is non-zero.
timeout is the time to wait in seconds for the command before exiting.
None means no timeout.
Returns:
A tuple of stdout and stderr from running the command.
Raises:
RemoteCommandError: If there was a problem issuing the command.
"""
raise NotImplementedError()
@abc.abstractmethod
def RemoteCopy(self, file_path, remote_path='', copy_to=True):
"""Copies a file to or from the VM.
Args:
file_path: Local path to file.
remote_path: Optional path of where to copy file on remote host.
copy_to: True to copy to vm, False to copy from vm.
Raises:
RemoteCommandError: If there was a problem copying the file.
"""
raise NotImplementedError()
@abc.abstractmethod
def WaitForBootCompletion(self):
"""Waits until VM is has booted.
Implementations of this method should set the 'bootable_time' attribute
and the 'hostname' attribute.
"""
raise NotImplementedError()
def OnStartup(self):
"""Performs any necessary setup on the VM specific to the OS.
This will be called once immediately after the VM has booted.
"""
pass
def PrepareVMEnvironment(self):
"""Performs any necessary setup on the VM specific to the OS.
This will be called once after setting up scratch disks.
"""
pass
@abc.abstractmethod
def Install(self, package_name):
"""Installs a PerfKit package on the VM."""
raise NotImplementedError()
@abc.abstractmethod
def Uninstall(self, package_name):
"""Uninstalls a PerfKit package on the VM."""
raise NotImplementedError()
@abc.abstractmethod
def PackageCleanup(self):
"""Cleans up all installed packages.
Deletes the temp directory, restores packages, and uninstalls all
PerfKit packages.
"""
raise NotImplementedError()
def SetupLocalDisks(self):
"""Perform OS specific setup on any local disks that exist."""
pass
def PushFile(self, source_path, remote_path=''):
"""Copies a file or a directory to the VM.
Args:
source_path: The location of the file or directory on the LOCAL machine.
remote_path: The destination of the file on the REMOTE machine, default
is the home directory.
"""
self.RemoteCopy(source_path, remote_path)
def PullFile(self, local_path, remote_path):
"""Copies a file or a directory from the VM to the local machine.
Args:
local_path: string. The destination path of the file or directory on the
local machine.
remote_path: string. The source path of the file or directory on the
remote machine.
"""
self.RemoteCopy(local_path, remote_path, copy_to=False)
def PushDataFile(self, data_file, remote_path=''):
"""Upload a file in perfkitbenchmarker.data directory to the VM.
Args:
data_file: The filename of the file to upload.
remote_path: The destination for 'data_file' on the VM. If not specified,
the file will be placed in the user's home directory.
Raises:
perfkitbenchmarker.data.ResourceNotFound: if 'data_file' does not exist.
"""
file_path = data.ResourcePath(data_file)
self.PushFile(file_path, remote_path)
def RenderTemplate(self, template_path, remote_path, context):
"""Renders a local Jinja2 template and copies it to the remote host.
The template will be provided variables defined in 'context', as well as a
variable named 'vm' referencing this object.
Args:
template_path: string. Local path to jinja2 template.
remote_path: string. Remote path for rendered file on the remote vm.
context: dict. Variables to pass to the Jinja2 template during rendering.
Raises:
jinja2.UndefinedError: if template contains variables not present in
'context'.
RemoteCommandError: If there was a problem copying the file.
"""
with open(template_path) as fp:
template_contents = fp.read()
environment = jinja2.Environment(undefined=jinja2.StrictUndefined)
template = environment.from_string(template_contents)
prefix = 'pkb-' + os.path.basename(template_path)
with vm_util.NamedTemporaryFile(prefix=prefix, dir=vm_util.GetTempDir(),
delete=False) as tf:
tf.write(template.render(vm=self, **context))
tf.close()
self.RemoteCopy(tf.name, remote_path)
@abc.abstractmethod
def _CreateScratchDiskFromDisks(self, disk_spec, disks):
"""Helper method to prepare data disks.
Given a list of BaseDisk objects, this will do most of the work creating,
attaching, striping, formatting, and mounting them. If multiple BaseDisk
objects are passed to this method, it will stripe them, combining them
into one 'logical' data disk (it will be treated as a single disk from a
benchmarks perspective). This is intended to be called from within a cloud
specific VM's CreateScratchDisk method.
Args:
disk_spec: The BaseDiskSpec object corresponding to the disk.
disks: A list of the disk(s) to be created, attached, striped,
formatted, and mounted. If there is more than one disk in
the list, then they will be striped together.
"""
raise NotImplementedError()
@property
def num_cpus(self):
"""Gets the number of CPUs on the VM.
Returns:
The number of CPUs on the VM.
"""
if self._num_cpus is None:
self._num_cpus = self._GetNumCpus()
return self._num_cpus
@abc.abstractmethod
def _GetNumCpus(self):
"""Returns the number of logical CPUs on the VM.
This method does not cache results (unlike "num_cpus").
"""
raise NotImplementedError()
@property
def total_memory_kb(self):
"""Gets the amount of memory on the VM.
Returns:
The number of kilobytes of memory on the VM.
"""
if not self._total_memory_kb:
self._total_memory_kb = self._GetTotalMemoryKb()
return self._total_memory_kb
@abc.abstractmethod
def _GetTotalMemoryKb(self):
"""Returns the amount of physical memory on the VM in Kilobytes.
This method does not cache results (unlike "total_memory_kb").
"""
raise NotImplementedError()
def IsReachable(self, target_vm):
"""Indicates whether the target VM can be reached from it's internal ip.
Args:
target_vm: The VM whose reachability is being tested.
Returns:
True if the internal ip address of the target VM can be reached, false
otherwise.
"""
if target_vm not in self._reachable:
if target_vm.internal_ip:
self._reachable[target_vm] = self._TestReachable(target_vm.internal_ip)
else:
self._reachable[target_vm] = False
return self._reachable[target_vm]
@abc.abstractmethod
def _TestReachable(self, ip):
"""Returns True if the VM can reach the ip address and False otherwise."""
raise NotImplementedError()
def StartBackgroundWorkload(self):
"""Start the background workload."""
for workload in background_workload.BACKGROUND_WORKLOADS:
if workload.IsEnabled(self):
if self.OS_TYPE in workload.EXCLUDED_OS_TYPES:
raise NotImplementedError()
workload.Start(self)
def StopBackgroundWorkload(self):
"""Stop the background workoad."""
for workload in background_workload.BACKGROUND_WORKLOADS:
if workload.IsEnabled(self):
if self.OS_TYPE in workload.EXCLUDED_OS_TYPES:
raise NotImplementedError()
workload.Stop(self)
def PrepareBackgroundWorkload(self):
"""Prepare for the background workload."""
for workload in background_workload.BACKGROUND_WORKLOADS:
if workload.IsEnabled(self):
if self.OS_TYPE in workload.EXCLUDED_OS_TYPES:
raise NotImplementedError()
workload.Prepare(self)
|
apache-2.0
|
benjyw/kythe
|
kythe/java/com/google/devtools/kythe/platform/java/JavacOptionsUtils.java
|
9117
|
/*
* Copyright 2014 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.devtools.kythe.platform.java;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.common.base.Joiner;
import com.google.common.base.Predicates;
import com.google.common.base.Splitter;
import com.google.common.base.StandardSystemProperty;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import com.google.common.collect.PeekingIterator;
import com.google.devtools.kythe.proto.Analysis.CompilationUnit;
import com.google.devtools.kythe.proto.Java.JavaDetails;
import com.google.protobuf.Any;
import com.google.protobuf.InvalidProtocolBufferException;
import com.sun.tools.javac.api.JavacTool;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.main.Option;
import com.sun.tools.javac.util.Context;
import java.nio.charset.Charset;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import javax.annotation.Nullable;
import javax.tools.OptionChecker;
/** A utility class for dealing with javac command-line options. */
public class JavacOptionsUtils {
private static final ImmutableList<String> JRE_JARS =
ImmutableList.of(
"lib/rt.jar", "lib/resources.jar", "lib/jsse.jar", "lib/jce.jar", "lib/charsets.jar");
private static final ImmutableList<String> JRE_PATHS;
static {
ImmutableList.Builder<String> paths = ImmutableList.builder();
Path javaHome = Paths.get(StandardSystemProperty.JAVA_HOME.value());
for (String jreJar : JRE_JARS) {
paths.add(javaHome.resolve(jreJar).toString());
}
JRE_PATHS = paths.build();
}
private static final Splitter PATH_SPLITTER = Splitter.on(':').trimResults().omitEmptyStrings();
private static final Joiner PATH_JOINER = Joiner.on(':').skipNulls();
/** Returns a new list of options with only javac compiler supported options. */
public static List<String> removeUnsupportedOptions(List<String> rawOptions) {
List<String> options = new ArrayList<>();
ImmutableList<OptionChecker> optionCheckers =
ImmutableList.of(JavacTool.create(), new JavacFileManager(new Context(), false, UTF_8));
PeekingIterator<String> it =
Iterators.peekingIterator(
Iterators.filter(
rawOptions.iterator(),
Predicates.not(o -> o.startsWith("-Xlint") || o.startsWith("-Werror"))));
outer:
while (it.hasNext()) {
for (OptionChecker optionChecker : optionCheckers) {
int arity = optionChecker.isSupportedOption(it.peek());
if (arity > 0 && it.peek().indexOf(':') != -1) {
// For "conjoined" flags (e.g., -flag:arg) we want to consume just command-line option.
arity = 0;
}
if (arity != -1) {
Iterators.addAll(options, Iterators.limit(it, arity + 1));
continue outer;
}
}
it.next();
}
return options;
}
/** Removes the given {@link Option}s (and their arguments) from {@code options}. */
public static List<String> removeOptions(List<String> options, Set<Option> opts) {
for (int i = 0; i < options.size(); ) {
String opt = options.get(i);
boolean matched = false;
for (Option o : opts) {
if (o.matches(opt)) {
matched = true;
options.subList(i, i + (o.hasArg() ? 2 : 1)).clear();
break;
}
}
if (!matched) {
i++;
}
}
return options;
}
/**
* Extract the encoding flag from the list of javac options. If the flag is specified more than
* once, returns the last copy, which matches javac's behavior. If the flag is not specified,
* returns null.
*/
public static @Nullable Charset getEncodingOption(List<String> options) {
int i = options.lastIndexOf("-encoding");
return (i >= 0) ? Charset.forName(options.get(i + 1)) : null;
}
/** If there is no encoding set, make sure to set the default encoding. */
public static List<String> ensureEncodingSet(List<String> options, Charset defaultEncoding) {
if (getEncodingOption(options) == null) {
options.add("-encoding");
options.add(defaultEncoding.name());
}
return options;
}
/**
* Update the command line arguments based on {@code compilationUnit}'s {@code JavaDetails} (if
* present) and the JRE jars.
*
* @param arguments the command line arguments to be updated
* @param compilationUnit the compilation unit in which to look for {@code JavaDetails}
*/
public static void updateArgumentsWithJavaOptions(
List<String> arguments, CompilationUnit compilationUnit) {
JavaDetails javaDetails = null;
for (Any detail : compilationUnit.getDetailsList()) {
if (detail.is(JavaDetails.class)) {
try {
javaDetails = detail.unpack(JavaDetails.class);
} catch (InvalidProtocolBufferException e) {
throw new IllegalArgumentException("Error in extracting JavaDetails", e);
}
break; // assume that <= 1 of these is a JavaDetails
}
}
// Use JavaDetails if present, otherwise use the default (system) properties.
if (javaDetails != null) {
updateArgumentsFromJavaDetails(arguments, javaDetails);
} else {
updateArgumentsFromSystemProperties(arguments);
}
}
private static void updateArgumentsFromJavaDetails(
List<String> arguments, JavaDetails javaDetails) {
updatePathArguments(arguments, Option.CLASS_PATH, javaDetails.getClasspathList());
updatePathArguments(arguments, Option.SOURCE_PATH, javaDetails.getSourcepathList());
updatePathArguments(arguments, Option.BOOT_CLASS_PATH, javaDetails.getBootclasspathList());
// just append the Java options to the arguments, separated by spaces
// (assumes that this is a series of "option" followed by "value" entries)
if (!javaDetails.getExtraJavacoptsList().isEmpty()) {
arguments.add(Joiner.on(' ').join(javaDetails.getExtraJavacoptsList()));
}
}
private static void updateArgumentsFromSystemProperties(List<String> arguments) {
ImmutableList.Builder<String> paths = ImmutableList.builder();
paths.addAll(extractArgumentPaths(arguments, Option.BOOT_CLASS_PATH));
paths.addAll(JRE_PATHS);
arguments.add(Option.BOOT_CLASS_PATH.getPrimaryName());
arguments.add(PATH_JOINER.join(paths.build()));
}
private static void updatePathArguments(
List<String> arguments, Option option, List<String> pathList) {
ImmutableList.Builder<String> pathEntries = ImmutableList.builder();
// We need to call extractArgumentPaths() even if we don't use the return value because it
// strips out any existing command-line-specified values from 'arguments'.
List<String> argumentPaths = extractArgumentPaths(arguments, option);
List<String> detailsPaths = extractDetailsPaths(pathList);
// Use paths specified in the JavaDetails' pathList if present; otherwise, use those
// specified on the command line.
if (!detailsPaths.isEmpty()) {
pathEntries.addAll(detailsPaths);
} else {
pathEntries.addAll(argumentPaths);
}
// If this is for the bootclasspath, append the paths to the system jars.
if (Option.BOOT_CLASS_PATH.equals(option)) {
pathEntries.addAll(JRE_PATHS);
}
ImmutableList<String> paths = pathEntries.build();
if (!paths.isEmpty()) {
arguments.add(option.getPrimaryName());
arguments.add(PATH_JOINER.join(paths));
}
}
/**
* Identify the paths associated with the specified option, remove them from the arguments list,
* and return them.
*/
private static ImmutableList<String> extractArgumentPaths(List<String> arguments, Option option) {
ImmutableList.Builder<String> paths = ImmutableList.builder();
for (int i = 0; i < arguments.size(); i++) {
if (option.matches(arguments.get(i))) {
if (i + 1 >= arguments.size()) {
throw new IllegalArgumentException(
String.format("Malformed %s argument: %s", option.getPrimaryName(), arguments));
}
arguments.remove(i);
paths.addAll(PATH_SPLITTER.split(arguments.remove(i)));
}
}
return paths.build();
}
private static List<String> extractDetailsPaths(List<String> pathList) {
ImmutableList.Builder<String> paths = ImmutableList.builder();
for (String entry : pathList) {
paths.addAll(PATH_SPLITTER.split(entry));
}
return paths.build();
}
}
|
apache-2.0
|
midnite8177/SaltarelleCompiler
|
Runtime/CoreLib/TimeSpan.cs
|
5675
|
using System.Runtime.CompilerServices;
namespace System {
[Imported(ObeysTypeSystem = true)]
[ScriptNamespace("ss")]
public struct TimeSpan : IComparable<TimeSpan>, IEquatable<TimeSpan> {
[InlineConstant]
public const long TicksPerMillisecond = 10000L;
[InlineConstant]
public const long TicksPerSecond = 10000000L;
[InlineConstant]
public const long TicksPerMinute = 600000000L;
[InlineConstant]
public const long TicksPerHour = 36000000000L;
[InlineConstant]
public const long TicksPerDay = 864000000000L;
public static readonly TimeSpan Zero = new TimeSpan(0);
//TODO
//public static readonly TimeSpan MinValue = new TimeSpan(long.MinValue);
//public static readonly TimeSpan MaxValue = new TimeSpan(long.MaxValue);
private TimeSpan(DummyTypeUsedToAddAttributeToDefaultValueTypeConstructor _) {
}
public TimeSpan(long ticks) {
}
[InlineCode("new {$System.TimeSpan}(((({hours} * 60 + {minutes}) * 60) + {seconds}) * 10000000)")]
public TimeSpan(int hours, int minutes, int seconds) {
}
[InlineCode("new {$System.TimeSpan}((((({days} * 24 + {hours}) * 60 + {minutes}) * 60) + {seconds}) * 10000000)")]
public TimeSpan(int days, int hours, int minutes, int seconds) {
}
[InlineCode("new {$System.TimeSpan}(((((({days} * 24 + {hours}) * 60 + {minutes}) * 60) + {seconds}) * 1000 + {milliseconds}) * 10000)")]
public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds) {
}
public int Days {
[InlineCode("{this}.ticks / 864000000000 | 0")]
get { return 0; }
}
public int Hours {
[InlineCode("{this}.ticks / 36000000000 % 24 | 0")]
get { return 0; }
}
public int Milliseconds {
[InlineCode("{this}.ticks / 10000 % 1000 | 0")]
get { return 0; }
}
public int Minutes {
[InlineCode("{this}.ticks / 600000000 % 60 | 0")]
get { return 0; }
}
public int Seconds {
[InlineCode("{this}.ticks / 10000000 % 60 | 0")]
get { return 0; }
}
[IntrinsicProperty]
public long Ticks {
get { return 0; }
}
public double TotalDays {
[InlineCode("{this}.ticks / 864000000000")]
get { return 0; }
}
public double TotalHours {
[InlineCode("{this}.ticks / 36000000000")]
get { return 0; }
}
public double TotalMilliseconds {
[InlineCode("{this}.ticks / 10000")]
get { return 0; }
}
public double TotalMinutes {
[InlineCode("{this}.ticks / 600000000")]
get { return 0; }
}
public double TotalSeconds {
[InlineCode("{this}.ticks / 10000000")]
get { return 0; }
}
[InlineCode("new {$System.TimeSpan}({this}.ticks + {ts}.ticks)")]
public TimeSpan Add(TimeSpan ts) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({this}.ticks - {ts}.ticks)")]
public TimeSpan Subtract(TimeSpan ts) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({$System.Math}.abs({this}.ticks))")]
public TimeSpan Duration() {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}(-{this}.ticks)")]
public TimeSpan Negate() {
return default(TimeSpan);
}
[InlineCode("{t1}.compareTo({t2})")]
public static int Compare(TimeSpan t1, TimeSpan t2) {
return 0;
}
public int CompareTo(TimeSpan other) {
return 0;
}
public bool Equals(TimeSpan other) {
return false;
}
[InlineCode("{t1}.ticks === {t2}.ticks")]
public static bool Equals(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("new {$System.TimeSpan}({value} * 864000000000)")]
public static TimeSpan FromDays(double value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({value} * 36000000000)")]
public static TimeSpan FromHours(double value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({value} * 10000)")]
public static TimeSpan FromMilliseconds(double value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({value} * 600000000)")]
public static TimeSpan FromMinutes(double value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({value} * 10000000)")]
public static TimeSpan FromSeconds(double value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({value})")]
public static TimeSpan FromTicks(long value) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({t1}.ticks + {t2}.ticks)")]
public static TimeSpan operator+(TimeSpan t1, TimeSpan t2) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({t1}.ticks - {t2}.ticks)")]
public static TimeSpan operator-(TimeSpan t1, TimeSpan t2) {
return default(TimeSpan);
}
[InlineCode("{t1}.ticks === {t2}.ticks")]
public static bool operator==(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("{t1}.ticks !== {t2}.ticks")]
public static bool operator!=(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("{t1}.ticks > {t2}.ticks")]
public static bool operator>(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("{t1}.ticks >= {t2}.ticks")]
public static bool operator>=(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("{t1}.ticks < {t2}.ticks")]
public static bool operator<(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("{t1}.ticks <= {t2}.ticks")]
public static bool operator<=(TimeSpan t1, TimeSpan t2) {
return false;
}
[InlineCode("new {$System.TimeSpan}(-{ts}.ticks)")]
public static TimeSpan operator-(TimeSpan ts) {
return default(TimeSpan);
}
[InlineCode("new {$System.TimeSpan}({ts}.ticks)")]
public static TimeSpan operator+(TimeSpan ts) {
return default(TimeSpan);
}
}
}
|
apache-2.0
|
kebenxiaoming/owncloudRedis
|
apps/gallery/l10n/en_GB.php
|
583
|
<?php
$TRANSLATIONS = array(
"Pictures" => "Pictures",
"Picture view" => "Picture view",
"Next" => "Next",
"Play" => "Play",
"Pause" => "Pause",
"Previous" => "Previous",
"Close" => "Close",
"Error loading slideshow template" => "Error loading slideshow template",
"Share" => "Share",
"No pictures found! If you upload pictures in the files app, they will be displayed here." => "No pictures found! If you upload pictures in the files app, they will be displayed here.",
"shared by %s" => "shared by %s",
"File list" => "File list"
);
$PLURAL_FORMS = "nplurals=2; plural=(n != 1);";
|
apache-2.0
|
lime-company/lime-security-powerauth-push
|
powerauth-push-server/src/main/java/io/getlime/push/controller/rest/PushCampaignController.java
|
15715
|
/*
* Copyright 2016 Wultra s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.getlime.push.controller.rest;
import io.getlime.core.rest.model.base.request.ObjectRequest;
import io.getlime.core.rest.model.base.response.ObjectResponse;
import io.getlime.core.rest.model.base.response.Response;
import io.getlime.push.errorhandling.exceptions.PushServerException;
import io.getlime.push.model.base.PagedResponse;
import io.getlime.push.model.entity.ListOfUsers;
import io.getlime.push.model.entity.PushMessageBody;
import io.getlime.push.model.request.CreateCampaignRequest;
import io.getlime.push.model.response.*;
import io.getlime.push.model.validator.CreateCampaignRequestValidator;
import io.getlime.push.repository.PushCampaignRepository;
import io.getlime.push.repository.PushCampaignUserRepository;
import io.getlime.push.repository.model.PushCampaignEntity;
import io.getlime.push.repository.model.PushCampaignUserEntity;
import io.getlime.push.repository.serialization.JsonSerialization;
import io.swagger.v3.oas.annotations.Operation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.List;
import java.util.Optional;
/**
* Controller for push campaign related methods
*
* @author Martin Tupy, martin.tupy.work@gmail.com
*/
@RestController
@RequestMapping(value = "push/campaign")
public class PushCampaignController {
private static final Logger logger = LoggerFactory.getLogger(PushCampaignController.class);
private final PushCampaignRepository pushCampaignRepository;
private final PushCampaignUserRepository pushCampaignUserRepository;
private final JsonSerialization jsonSerialization;
/**
* Constructor with autowired dependencies.
*
* @param pushCampaignRepository Push campaign repository.
* @param pushCampaignUserRepository Push campaign user repository.
* @param jsonSerialization Helper for JSON serialization.
*/
@Autowired
public PushCampaignController(PushCampaignRepository pushCampaignRepository,
PushCampaignUserRepository pushCampaignUserRepository, JsonSerialization jsonSerialization) {
this.pushCampaignRepository = pushCampaignRepository;
this.pushCampaignUserRepository = pushCampaignUserRepository;
this.jsonSerialization = jsonSerialization;
}
/**
* Create a campaign for specific app.
*
* @param request Id of specific app, body of specific messageBody
* @return ID for created campaign.
* @throws PushServerException In case request is invalid.
*/
@PostMapping(value = "create")
@Operation(summary = "Create a campaign",
description = "Creating a campaign requires in request body an application id to be related with " +
"and a certain message that users will receive")
public ObjectResponse<CreateCampaignResponse> createCampaign(@RequestBody ObjectRequest<CreateCampaignRequest> request) throws PushServerException {
CreateCampaignRequest requestObject = request.getRequestObject();
if (requestObject == null) {
throw new PushServerException("Request object must not be empty");
}
logger.info("Received createCampaign request, app ID: {}", requestObject.getAppId());
String errorMessage = CreateCampaignRequestValidator.validate(requestObject);
if (errorMessage != null) {
throw new PushServerException(errorMessage);
}
PushCampaignEntity campaign = new PushCampaignEntity();
PushMessageBody message = requestObject.getMessage();
String messageString = jsonSerialization.serializePushMessageBody(message);
campaign.setAppId(requestObject.getAppId());
campaign.setSent(false);
campaign.setTimestampCreated(new Date());
campaign.setMessage(messageString);
campaign = pushCampaignRepository.save(campaign);
CreateCampaignResponse response = new CreateCampaignResponse();
response.setId(campaign.getId());
logger.info("The createCampaign request succeeded, app ID: {}, campaign ID: {}", requestObject.getAppId(), campaign.getId());
return new ObjectResponse<>(response);
}
/**
* Removes a certain campaign along with users related to this campaign.
*
* @param campaignId Identifier for deleting a campaign
* @return Remove campaign status response.
*/
@RequestMapping(value = "{id}/delete", method = { RequestMethod.POST, RequestMethod.DELETE })
@Operation(summary = "Delete a campaign",
description = "Specified with id. Also users associated with this campaign are going to be deleted. If deletion was applied then deleted status is true. False if such campaign does not exist")
public ObjectResponse<DeleteCampaignResponse> deleteCampaign(@PathVariable(value = "id") Long campaignId) {
logger.info("Received deleteCampaign request, campaign ID: {}", campaignId);
DeleteCampaignResponse deleteCampaignResponse = new DeleteCampaignResponse();
final Optional<PushCampaignEntity> campaignEntityOptional = pushCampaignRepository.findById(campaignId);
if (!campaignEntityOptional.isPresent()) {
deleteCampaignResponse.setDeleted(false);
} else {
pushCampaignRepository.delete(campaignEntityOptional.get());
deleteCampaignResponse.setDeleted(true);
}
pushCampaignUserRepository.deleteByCampaignId(campaignId);
logger.info("The deleteCampaign request succeeded, campaign ID: {}", campaignId);
return new ObjectResponse<>(deleteCampaignResponse);
}
/**
* Method used for getting a specific campaign
*
* @param campaignId Id of specific campaign
* @return Campaign Response
* @throws PushServerException In case campaign with provided ID does not exist.
*/
@GetMapping(value = "{id}/detail")
@Operation(summary = "Return details about campaign",
description = "Campaign specified by id. Details contain campaign id, application id, status if campaign was sent and message.")
public ObjectResponse<CampaignResponse> getCampaign(@PathVariable(value = "id") Long campaignId) throws PushServerException {
logger.debug("Received getCampaign request, campaign ID: {}", campaignId);
final PushCampaignEntity campaign = findPushCampaignById(campaignId);
CampaignResponse campaignResponse = new CampaignResponse();
campaignResponse.setId(campaign.getId());
campaignResponse.setSent(campaign.isSent());
campaignResponse.setAppId(campaign.getAppId());
PushMessageBody message = jsonSerialization.deserializePushMessageBody(campaign.getMessage());
campaignResponse.setMessage(message);
logger.debug("The getCampaign request succeeded, campaign ID: {}", campaignId);
return new ObjectResponse<>(campaignResponse);
}
/**
* Method used for getting a list of campaigns.
*
* @param all If true, method returns list of all campaigns. If false, it returns
* only campaigns that were not sent yet.
* @return List of campaigns.
* @throws PushServerException In case campaign message cannot be deserialized.
*/
@GetMapping(value = "list")
@Operation(summary = "Return a detailed list of campaigns",
description = "Restricted with all param. This parameter decides if return campaigns that are 'only sent'(statement false)" +
" or return all registered campaigns (statement true). Details are same as in getCampaign method")
public ObjectResponse<ListOfCampaignsResponse> getListOfCampaigns(@RequestParam(value = "all", required = false) boolean all) throws PushServerException {
logger.debug("Received getListOfCampaigns request");
// Fetch campaigns from the repository
Iterable<PushCampaignEntity> campaignList;
if (all) {
campaignList = pushCampaignRepository.findAll();
} else {
campaignList = pushCampaignRepository.findAllBySent(false);
}
// Prepare response with list of campaigns
ListOfCampaignsResponse listOfCampaignsResponse = new ListOfCampaignsResponse();
for (PushCampaignEntity campaign : campaignList) {
CampaignResponse campaignResponse = new CampaignResponse();
campaignResponse.setId(campaign.getId());
campaignResponse.setAppId(campaign.getAppId());
campaignResponse.setSent(campaign.isSent());
PushMessageBody pushMessageBody = jsonSerialization.deserializePushMessageBody(campaign.getMessage());
campaignResponse.setMessage(pushMessageBody);
listOfCampaignsResponse.add(campaignResponse);
}
logger.debug("The getListOfCampaigns request succeeded");
return new ObjectResponse<>(listOfCampaignsResponse);
}
/**
* Add specific request to specific campaign
*
* @param campaignId ID of certain campaign
* @param request List of IDs referred to request
* @return Response status
* @throws PushServerException In case campaign with given ID does not exist.
*/
@RequestMapping(value = "{id}/user/add", method = { RequestMethod.POST, RequestMethod.PUT })
@Operation(summary = "Associate users to campaign",
description = "Users are identified in request body as an array of strings in request body.")
public Response addUsersToCampaign(@PathVariable(value = "id") Long campaignId, @RequestBody ObjectRequest<ListOfUsers> request) throws PushServerException {
checkRequestNullity(request);
logger.info("Received addUsersToCampaign request, campaign ID: {}, users: {}", campaignId, request.getRequestObject());
final PushCampaignEntity campaignEntity = findPushCampaignById(campaignId);
ListOfUsers listOfUsers = request.getRequestObject();
for (String user : listOfUsers) {
if (pushCampaignUserRepository.findFirstByUserIdAndCampaignId(user, campaignId) == null) {
PushCampaignUserEntity pushCampaignUserEntity = new PushCampaignUserEntity();
pushCampaignUserEntity.setCampaignId(campaignId);
pushCampaignUserEntity.setUserId(user);
pushCampaignUserEntity.setAppId(campaignEntity.getAppId());
pushCampaignUserEntity.setTimestampCreated(new Date());
pushCampaignUserRepository.save(pushCampaignUserEntity);
logger.info("The addUsersToCampaign request succeeded, campaign ID: {}", campaignId);
} else {
logger.warn("Duplicate user entry for push campaign: {}", user);
}
}
return new Response();
}
/**
* Method for getting users from specific campaign in paged format
*
* @param id Campaign id
* @param pageable Format for pagination (?page=x&size=y), where "x" is chosen page and "y" is size is number of elements per page, beginning from zero
* @return Campaign id, list of users
*/
@GetMapping(value = "{id}/user/list")
@Operation(summary = "Return list of users",
description = "Return all users' ids from campaign that is specified in URI {id} variable. " +
"Users are shown in paginated format based on parameters assigned in URI. " +
"Page param defines which page to show (start from 0) and size param which defines how many user ids to show per page")
public PagedResponse<ListOfUsersFromCampaignResponse> getListOfUsersFromCampaign(@PathVariable(value = "id") Long id, Pageable pageable) {
logger.debug("Received getListOfUsersFromCampaign request, campaign ID: {}", id);
ListOfUsersFromCampaignResponse listOfUsersFromCampaignResponse = new ListOfUsersFromCampaignResponse();
List<PushCampaignUserEntity> users = pushCampaignUserRepository.findAllByCampaignId(id, pageable);
ListOfUsers listOfUsers = new ListOfUsers();
for (PushCampaignUserEntity user : users) {
listOfUsers.add(user.getUserId());
}
listOfUsersFromCampaignResponse.setCampaignId(id);
listOfUsersFromCampaignResponse.setUsers(listOfUsers);
PagedResponse<ListOfUsersFromCampaignResponse> listOfUsersPagedResponse = new PagedResponse<>(listOfUsersFromCampaignResponse);
listOfUsersPagedResponse.setPage(pageable.getPageNumber());
listOfUsersPagedResponse.setSize(pageable.getPageSize());
logger.debug("The getListOfUsersFromCampaign request succeeded, campaign ID: {}", id);
return listOfUsersPagedResponse;
}
/**
* Removes campaign users identified by list of users userID and campaignID
*
* @param id Campaign ID
* @param request List of users to remove
* @return Response status
*/
@RequestMapping(value = "{id}/user/delete", method = { RequestMethod.POST, RequestMethod.DELETE })
@Operation(summary = "Delete users from campaign",
description = "Delete users from certain campaign specified with {id} variable in URI." +
"Users are described as list of their ids in Request body")
public Response deleteUsersFromCampaign(@PathVariable(value = "id") Long id, @RequestBody ObjectRequest<ListOfUsers> request) {
logger.info("Received deleteUsersFromCampaign request, campaign ID: {}, users: {}", id, request.getRequestObject());
ListOfUsers listOfUsers = request.getRequestObject();
for (String user : listOfUsers) {
pushCampaignUserRepository.deleteByCampaignIdAndUserId(id, user);
}
logger.info("The deleteUsersFromCampaign request succeeded, campaign ID: {}", id);
return new Response();
}
/**
* Method used for checking exception about nullity of http request
*
* @param request An object request to check the nullity
* @throws PushServerException In case request object is null.
*/
private void checkRequestNullity(ObjectRequest<?> request) throws PushServerException {
if (request.getRequestObject() == null) {
throw new PushServerException("Empty requestObject data");
}
}
/**
* Find push campaign entity by ID.
* @param campaignId Campaign ID.
* @return Push campaign entity.
* @throws PushServerException Thrown when campaign entity does not exists.
*/
private PushCampaignEntity findPushCampaignById(Long campaignId) throws PushServerException {
final Optional<PushCampaignEntity> campaignEntityOptional = pushCampaignRepository.findById(campaignId);
if (!campaignEntityOptional.isPresent()) {
throw new PushServerException("Campaign with entered ID does not exist");
}
return campaignEntityOptional.get();
}
}
|
apache-2.0
|
boruxu/qpmtools
|
src/main/java/cn/edu/buaa/g305/qpm/processManagement/server/TagServer.java
|
382
|
package cn.edu.buaa.g305.qpm.processManagement.server;
import java.util.List;
import cn.edu.buaa.g305.qpm.processManagement.domian.Tag;
public interface TagServer {
Tag getByName(String name);
Tag getById(String id);
void delete(String id);
void deleteByName(String name);
Tag save(Tag Tag);
Tag update(Tag Tag,String id);
List<Tag> getAllList();
}
|
apache-2.0
|
Anthonyo2015/bfdocker
|
besserver/cli_tool/node_modules/saxpath/test/saxpath.js
|
14733
|
var assert = require('assert');
var TapeRecorder = require('./tape_recorder');
var fs = require('fs');
var sax = require('sax');
var saxpath = process.env.JS_COV ? require('../lib-cov') : require('../lib');
describe('SaXPath', function() {
it('should match /bookstore', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/bookstore', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape = recorder.box[0];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'bookstore');
done();
}
});
it('should match /bookstore/book', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/bookstore/book', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 4);
var tape;
var i;
for (i = 0; i < 4; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'book');
}
done();
}
});
it('should match /bookstore/book[@category="COOKING"]', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/bookstore/book[@category="COOKING"]', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape;
var i;
for (i = 0; i < 1; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'book');
}
done();
}
});
it('should not match /bookstore/title', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/bookstore/title', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 0);
done();
}
});
it('should match //book', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//book', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 4);
var tape;
var i;
for (i = 0; i < 4; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'book');
}
done();
}
});
it('should match //book[@category="COOKING"]', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//book[@category="COOKING"]', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape = recorder.box[0];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'book');
assert.deepEqual(tape[1].openTag.attributes, { category: 'COOKING' });
done();
}
});
it('should match //book/title', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//book/title', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 4);
var tape;
var i;
for (i = 0; i < 4; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'title');
}
done();
}
});
it('should match //book//title', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//book//title', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 4);
var tape;
var i;
for (i = 0; i < 4; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'title');
}
done();
}
});
it('should match all nested nodes in //node', function(done) {
var fileStream = fs.createReadStream('test/inception.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//node', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 3);
var tape;
var i;
for (i = 0; i < 3; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'node');
}
done();
}
});
it('should be able to match nodes with namespaces in //test:node', function(done) {
var fileStream = fs.createReadStream('test/namespace.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//test:node', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape;
var i;
for (i = 0; i < 1; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'test:node');
}
done();
}
});
it('should match node, namespace and attribute names with numbers and underscores in them', function(done) {
var fileStream = fs.createReadStream('test/numbers.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//nam3_spac3:nod3[@special_attribut3_name="foo"]/subnod3', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape = recorder.box[0];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'subnod3');
done();
}
});
it('should match attributes values with numbers, underscores and spaces', function(done) {
var fileStream = fs.createReadStream('test/numbers.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//nam3_spac3:nod3[@special_attribut3_name="0 some_value"]/subnod3', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape = recorder.box[0];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'subnod3');
done();
}
});
it('should throw a SyntaxError if a namespace starts with a number', function(done) {
var fileStream = fs.createReadStream('test/bookstore.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
try {
var streamer = new saxpath.SaXPath(saxParser, '/0:test', recorder);
assert.fail(); // should not execute this instruction
} catch (err) {
assert.equal(err.name, 'SyntaxError');
done();
}
});
it('should be able to match nodes in /root/*/somenode', function(done) {
var fileStream = fs.createReadStream('test/wildcard.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/root/*/somenode', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 3);
var tape;
var i;
for (i = 0; i < 3; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'somenode');
}
done();
}
});
it('should be able to match namespaced nodes with wildcard //test:*', function(done) {
var fileStream = fs.createReadStream('test/namespace.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//test:*', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 1);
var tape;
var i;
for (i = 0; i < 1; ++i) {
tape = recorder.box[i];
assert.ok(tape.length > 0);
assert.equal(tape[1].openTag.name, 'test:node');
}
done();
}
});
it('should be able to find CDATA values', function(done) {
var fileStream = fs.createReadStream('test/cdata.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '/root/node', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 3); // 3 matches on /root/node
assert.equal(recorder.box[0][2].openCData, true);
assert.equal(recorder.box[0][3].cdata, 'Sample data value');
assert.equal(recorder.box[0][4].closeCData, true);
assert.equal(recorder.box[2][2].openCData, true);
assert.equal(recorder.box[2][3].cdata, 'Other CDATA value');
assert.equal(recorder.box[2][4].closeCData, true);
done();
}
});
it('should match //node-1', function(done) {
var fileStream = fs.createReadStream('test/hyphens.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//node-1', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 2);
assert.equal(recorder.box[0][1].openTag.name, 'node-1');
assert.equal(recorder.box[1][1].openTag.name, 'node-1');
done();
}
});
it('should match //test-ns:node-1', function(done) {
var fileStream = fs.createReadStream('test/namespace-hyphens.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//test-ns:node-1', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 2);
assert.equal(recorder.box[0][1].openTag.name, 'test-ns:node-1');
assert.equal(recorder.box[1][1].openTag.name, 'test-ns:node-1');
done();
}
});
it('should match //node.1', function(done) {
var fileStream = fs.createReadStream('test/dots.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//node.1', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 2);
assert.equal(recorder.box[0][1].openTag.name, 'node.1');
assert.equal(recorder.box[1][1].openTag.name, 'node.1');
done();
}
});
it('should match //test.ns:node.1', function(done) {
var fileStream = fs.createReadStream('test/namespace-dots.xml');
var recorder = new TapeRecorder();
var saxParser = sax.createStream(true);
var streamer = new saxpath.SaXPath(saxParser, '//test.ns:node.1', recorder);
saxParser.on('end', testNodesRecorded);
fileStream.pipe(saxParser);
function testNodesRecorded() {
assert.equal(recorder.box.length, 2);
assert.equal(recorder.box[0][1].openTag.name, 'test.ns:node.1');
assert.equal(recorder.box[1][1].openTag.name, 'test.ns:node.1');
done();
}
});
});
|
apache-2.0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.