|
LightHub
|
Functions | |
| int | owUpdate () |
| int | owSetup (owChangedType owCh) |
| int | sensors_loop (void) |
| void | owLoop () |
| int | owFind (DeviceAddress addr) |
| void | owAdd (DeviceAddress addr) |
| void | setupOwIdle (void(*ptr)()) |
Variables | |
| OneWire * | oneWire = NULL |
| DeviceAddress * | term = NULL |
| uint16_t * | wstat = NULL |
| DallasTemperature * | sensors = NULL |
| short | si = 0 |
| int | t_count = 0 |
| unsigned long | owTimer = 0 |
| owChangedType | owChanged |
| void owAdd | ( | DeviceAddress | addr | ) |
| int owFind | ( | DeviceAddress | addr | ) |
| void owLoop | ( | ) |
| int owSetup | ( | owChangedType | owCh | ) |
| int owUpdate | ( | ) |
| int sensors_loop | ( | void | ) |
| void setupOwIdle | ( | void(*)() | ptr | ) |
| OneWire* oneWire = NULL |
| owChangedType owChanged |
| unsigned long owTimer = 0 |
| DallasTemperature* sensors = NULL |
| short si = 0 |
| int t_count = 0 |
| DeviceAddress* term = NULL |
| uint16_t* wstat = NULL |


ngCookies
The ngCookies
module provides a convenient wrapper for reading and writing browser cookies.
See $cookies
and
$cookieStore
for usage.
First include angular-cookies.js
in your HTML:
<script src="angular.js">
<script src="angular-cookies.js">
You can download this file from the following places:
//ajax.googleapis.com/ajax/libs/angularjs/X.Y.Z/angular-cookies.js
bower install<EMAIL_ADDRESS>"//code.angularjs.org/X.Y.Z/angular-cookies.js"
where X.Y.Z is the AngularJS version you are running.
Then load the module in your application by adding it as a dependent module:
angular.module('app', ['ngCookies']);
With that you're ready to get started!
| Name | Description |
|---|---|
| $cookies | Provides read/write access to browser's cookies. |
| $cookieStore | Provides a key-value (string-object) storage, that is backed by session cookies. Objects put or retrieved from this storage are automatically serialized or deserialized by angular's toJson/fromJson. |


KIBO
`Prev `__
K
`Next `__
--------------
**KIBO**: /ki:´boh/
1. [acronym] Knowledge In, Bullshit Out. A summary of what happens
whenever valid data is passed through an organization (or person) that
deliberately or accidentally disregards or ignores its significance.
Consider, for example, what an advertising campaign can do with a
product's actual specifications. Compare `*GIGO* <../G/GIGO.html>`__;
see also `*SNAFU principle* <../S/SNAFU-principle.html>`__.
2. James Parry , a Usenetter infamous for various
surrealist net.pranks and an uncanny, machine-assisted knack for joining
any thread in which his nom de guerre is mentioned. He has a website at
`http://www.kibo.com/ `__.
--------------
+---------------------------+----------------------------+---------------------------+
| `Prev `__ | `Up <../K.html>`__ | `Next `__ |
+---------------------------+----------------------------+---------------------------+
| kgbvax | `Home <../index.html>`__ | kiboze |
+---------------------------+----------------------------+---------------------------+


--- layout: post date: 2010-12-27 time: "09:00:00" authors: ["Greg Wilson"] title: Elimination tags: ["Content"] ---
I'm working up another essay on software design, and would like to ask readers of this blog how they handle something that comes up when simulating interacting agents. If your program models the behavior of a flock of birds, it probably looks something like this:
# create birds birds = [] for i in range(num_birds): new_bird = Bird(...parameters...) birds.append(new_bird) # simulate movement for t in range(num_timesteps): for b in birds: b.move(birds) # need access to other birds to calculate forces
There's a flaw in this—or at least, something questionable. By the time you are moving the last bird for time t, every other bird is effectively at time t+1. There are many solutions, the simplest of which is to calculate each bird's new position in one loop, then update the bird in another:
# simulate movement for t in range(num_timesteps): new_pos = [] for b in birds: p = b.next_position(birds) # doesn't move the bird new_pos.append(p) for (b, p) in zip(birds, temp): b.set_position(p)
(If you haven't run into it, the built-in function zip
takes two or more lists, and produces tuples of corresponding elements. For example, zip('abc', [1, 2, 3])
produces ('a', 1)
, ('b', 2)
, and ('c', 3)
.)
So far so good—but what if the things we're simulating can produce offspring, die, or eat one another? Offspring are relatively simple to handle: we just put them in a temporary list (or set), then append them to the main list after everything else has been moved.
Removing creatures that have died is a bit trickier, because modifying a list as we're looping over it may cause us to skip elements (we delete the element at location i, then advance our loop counter to i+1, and voila: the item that was at location i+1 but has been bumped down to location i is never seen in the loop). We can handle that either by "stuttering" the loop index:
i = 0 new_pos = [] while i < len(birds): state, p = birds[i].move(birds) if state == ALIVE: i += 1 new_pos.append(p) else: del birds[i]
or by moving creatures that haven't died into another list, and swapping at the end of the loop:
temp = [] for b in birds: state, p = b.move(birds) if state == ALIVE: temp.append((b, p)) birds = [] for (b, p) in temp: b.set_position(p) birds.append(b)
I think the second is less fragile—modifying structures as I'm looping over them always gives me the shivers—but either will do the job.
But now comes the hard case. What happens if birds can eat each other? If bird i eats bird j, for i<j, it's no different from bird j dying. But if bird j eats bird i, we have a problem, because bird i is already in the list of survivors. Do we search for it and delete it (in which case, the stuttering solution above is definitely not the one we want, because the indexing logic becomes even more fragile)? Or... or what? Set a "but actually dead" flag in the bird's record in the temporary list, and not move it back into the bird list after all in the second loop? What would you do, and why?


{% include 'includes/breadcrumbs.html' %}
{% include 'includes/optional-introduction.html' with value=self %}
{% include "includes/social_fields.html" %}
{% include "includes/row_siblings_in_section.html" with page=self %}
{# main content row #}
{% if self.prepared_key_info and self.prepared_in_depth %}


| 1 | package fr.sii.ogham.testing.assertion.email; | |
| 2 | ||
| 3 | import static fr.sii.ogham.testing.assertion.util.AssertionHelper.assertThat; | |
| 4 | import static fr.sii.ogham.testing.assertion.util.AssertionHelper.usingContext; | |
| 5 | import static fr.sii.ogham.testing.assertion.util.EmailUtils.getAlternativePart; | |
| 6 | import static fr.sii.ogham.testing.assertion.util.EmailUtils.getAttachments; | |
| 7 | import static fr.sii.ogham.testing.assertion.util.EmailUtils.getBodyPart; | |
| 8 | import static java.util.Arrays.asList; | |
| 9 | import static ogham.testing.jakarta.mail.Message.RecipientType.CC; | |
| 10 | import static ogham.testing.jakarta.mail.Message.RecipientType.TO; | |
| 11 | import static org.hamcrest.Matchers.hasSize; | |
| 12 | import static org.hamcrest.Matchers.lessThanOrEqualTo; | |
| 13 | ||
| 14 | import java.util.ArrayList; | |
| 15 | import java.util.Arrays; | |
| 16 | import java.util.Collection; | |
| 17 | import java.util.List; | |
| 18 | import java.util.function.Predicate; | |
| 19 | ||
| 20 | import ogham.testing.jakarta.mail.BodyPart; | |
| 21 | import ogham.testing.jakarta.mail.Message; | |
| 22 | import ogham.testing.jakarta.mail.MessagingException; | |
| 23 | import ogham.testing.jakarta.mail.Part; | |
| 24 | import ogham.testing.jakarta.mail.internet.InternetAddress; | |
| 25 | ||
| 26 | import org.hamcrest.Matcher; | |
| 27 | ||
| 28 | import fr.sii.ogham.testing.assertion.context.SingleMessageContext; | |
| 29 | import fr.sii.ogham.testing.assertion.filter.FileNamePredicate; | |
| 30 | import fr.sii.ogham.testing.assertion.util.AssertionRegistry; | |
| 31 | import fr.sii.ogham.testing.assertion.util.EmailUtils; | |
| 32 | import fr.sii.ogham.testing.util.HasParent; | |
| 33 | ||
| 34 | @SuppressWarnings("squid:S1192") | |
| 35 | public class FluentEmailAssert
 extends HasParent
 { | |
| 36 | /** | |
| 37 | * The list of messages that will be used for assertions | |
| 38 | */ | |
| 39 | private final List<? extends Message> actual; | |
| 40 | private int index; | |
| 41 | /** | |
| 42 | * Registry to register assertions | |
| 43 | */ | |
| 44 | private final AssertionRegistry registry; | |
| 45 | ||
| 46 | public FluentEmailAssert(Message actual, int index, P parent, AssertionRegistry registry) { | |
| 47 | this(Arrays.asList(actual), parent, registry); | |
| 48 | this.index = index; | |
| 49 | } | |
| 50 | ||
| 51 | public FluentEmailAssert(List<? extends Message> actual, P parent, AssertionRegistry registry) { | |
| 52 | super(parent); | |
| 53 | this.actual = actual; | |
| 54 | this.registry = registry; | |
| 55 | } | |
| 56 | ||
| 57 | /** | |
| 58 | * Make assertions on the subject of the message(s). | |
| 59 | * | |
| 60 | *
 | |
| 61 | * .receivedMessages().message(0) | |
| 62 | * .subject(is("foobar")) | |
| 63 | *
 | |
| 64 | * | |
| 65 | * Will check if the subject of the first message is exactly "foobar". | |
| 66 | * | |
| 67 | *
 | |
| 68 | * .receivedMessages().every() | |
| 69 | * .subject(is("foobar")) | |
| 70 | *
 | |
| 71 | * | |
| 72 | * Will check that the subject of every message is exactly "foobar". | |
| 73 | * | |
| 74 | * @param matcher | |
| 75 | * the assertion to apply on subject | |
| 76 | * @return the fluent API for chaining assertions on received message(s) | |
| 77 | */ | |
| 78 | public FluentEmailAssert
 subject(Matcher<? super String> matcher) { | |
| 79 | try { | |
| 80 | String desc = "subject of message ${messageIndex}"; | |
| 81 | int msgIdx = this.index; | |
| 82 | for (Message message : actual) { | |
| 83 | final int idx = msgIdx; | |
| 84 |
2
1. subject : removed call to fr/sii/ogham/testing/assertion/util/AssertionRegistry::register → NO_COVERAGE 2. lambda$subject$0 : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE |
registry.register(() -> assertThat(message.getSubject(), usingContext(desc, new SingleMessageContext(idx), matcher))); |
| 85 |
1
1. subject : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 86 | } | |
| 87 |
1
1. subject : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::subject → NO_COVERAGE |
return this; |
| 88 | } catch (MessagingException e) { | |
| 89 | throw new AssertionError("Failed to get subject of messsage", e); | |
| 90 | } | |
| 91 | } | |
| 92 | ||
| 93 | /** | |
| 94 | * Make assertions on the body of the message(s) using fluent API. The body | |
| 95 | * of the message is either: | |
| 96 | *
 | |
| 97 | *
The part of the message when it contains only one part
 | |
| 98 | *
The part with text or HTML mimetype if only one part with one of that | |
| 99 | * mimetype
 | |
| 100 | *
The second part with text or HTML mimetype if there are two text or | |
| 101 | * HTML parts
 | |
| 102 | *
 | |
| 103 | * | |
| 104 | *
 | |
| 105 | * .receivedMessages().message(0).body() | |
| 106 | * .contentAsString(is("email body")) | |
| 107 | * .contentType(is("text/plain")) | |
| 108 | *
 | |
| 109 | * | |
| 110 | * Will check if the body content of the first message is "email body" and | |
| 111 | * content-type of the first message is "text/plain". | |
| 112 | * | |
| 113 | *
 | |
| 114 | * .receivedMessages().every().body() | |
| 115 | * .contentAsString(is("email body")) | |
| 116 | * .contentType(is("text/plain")) | |
| 117 | *
 | |
| 118 | * | |
| 119 | * Will check that the body content of every message is "email body" and | |
| 120 | * content-type of every message is "text/plain". | |
| 121 | * | |
| 122 | * @return the fluent API for chaining assertions on received message(s) | |
| 123 | */ | |
| 124 | public FluentPartAssert<FluentEmailAssert
> body() { | |
| 125 | try { | |
| 126 | int msgIdx = this.index; | |
| 127 | List<PartWithContext> bodies = new ArrayList<>(); | |
| 128 | for (Message message : actual) { | |
| 129 | bodies.add(new PartWithContext(getBodyPart(message), "body", new SingleMessageContext(msgIdx))); | |
| 130 |
1
1. body : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 131 | } | |
| 132 |
1
1. body : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::body → NO_COVERAGE |
return new FluentPartAssert<>(bodies, this, registry); |
| 133 | } catch (MessagingException e) { | |
| 134 | throw new AssertionError("Failed to get body of messsage", e); | |
| 135 | } | |
| 136 | } | |
| 137 | ||
| 138 | /** | |
| 139 | * Make assertions on the alternative part of the message(s) using fluent | |
| 140 | * API. The alternative is useful when sending HTML email that may be | |
| 141 | * unreadable on some email clients. For example, a smartphone will display | |
| 142 | * the 2 or 3 first lines as a summary. Many smartphones will take the HTML | |
| 143 | * message as-is and will display HTML tags instead of content of email. | |
| 144 | * Alternative is used to provide a textual visualization of the message | |
| 145 | * that will be readable by any system. | |
| 146 | * | |
| 147 | *
 | |
| 148 | * The alternative of the message is either: | |
| 149 | *
 | |
| 150 | *
null if there is only one part
 | |
| 151 | *
null if there is only one text or HTML part
 | |
| 152 | *
the first part if there are more than one text or HTML part
 | |
| 153 | *
 | |
| 154 | * | |
| 155 | *
 | |
| 156 | * .receivedMessages().message(0).alternative() | |
| 157 | * .contentAsString(is("email alternative")) | |
| 158 | * .contentType(is("text/plain")) | |
| 159 | *
 | |
| 160 | * | |
| 161 | * Will check if the body content of the first message is "email | |
| 162 | * alternative" and content-type of the first message is "text/plain". | |
| 163 | * | |
| 164 | *
 | |
| 165 | * .receivedMessages().every().alternative() | |
| 166 | * .contentAsString(is("email alternative")) | |
| 167 | * .contentType(is("text/plain")) | |
| 168 | *
 | |
| 169 | * | |
| 170 | * Will check that the body content of every message is "email alternative" | |
| 171 | * and content-type of every message is "text/plain". | |
| 172 | * | |
| 173 | * @return the fluent API for chaining assertions on received message(s) | |
| 174 | */ | |
| 175 | public FluentPartAssert<FluentEmailAssert
> alternative() { | |
| 176 | try { | |
| 177 | int msgIdx = this.index; | |
| 178 | List<PartWithContext> bodies = new ArrayList<>(); | |
| 179 | for (Message message : actual) { | |
| 180 | bodies.add(new PartWithContext(getAlternativePart(message), "alternative", new SingleMessageContext(msgIdx))); | |
| 181 |
1
1. alternative : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 182 | } | |
| 183 |
1
1. alternative : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::alternative → NO_COVERAGE |
return new FluentPartAssert<>(bodies, this, registry); |
| 184 | } catch (MessagingException e) { | |
| 185 | throw new AssertionError("Failed to get body of messsage", e); | |
| 186 | } | |
| 187 | } | |
| 188 | ||
| 189 | /** | |
| 190 | * Make assertions on the body of the message(s). The body of the message is | |
| 191 | * either: | |
| 192 | *
 | |
| 193 | *
The part of the message when it contains only one part
 | |
| 194 | *
The part with text or HTML mimetype if only one part with one of that | |
| 195 | * mimetype
 | |
| 196 | *
The second part with text or HTML mimetype if there are two text or | |
| 197 | * HTML parts
 | |
| 198 | *
 | |
| 199 | * | |
| 200 | *
 | |
| 201 | * .receivedMessages().message(0) | |
| 202 | * .body(allOf(notNullValue(), instanceOf(MimeBodyPart.class)) | |
| 203 | *
 | |
| 204 | * | |
| 205 | * Will check if the body of the first message is not null and is a | |
| 206 | * MimeBodyPart instance. | |
| 207 | * | |
| 208 | *
 | |
| 209 | * .receivedMessages().every() | |
| 210 | * .body(allOf(notNullValue(), instanceOf(MimeBodyPart.class)) | |
| 211 | *
 | |
| 212 | * | |
| 213 | * Will check that the body of every message is not null and is a | |
| 214 | * MimeBodyPart instance. | |
| 215 | * | |
| 216 | *
 | |
| 217 | * You can use the {@link #body()} variant to make more powerful assertions. | |
| 218 | * | |
| 219 | * @param matcher | |
| 220 | * the assertion to apply on body | |
| 221 | * @param <T> | |
| 222 | * the type used for the matcher | |
| 223 | * @return the fluent API for chaining assertions on received message(s) | |
| 224 | */ | |
| 225 | public <T extends Part> FluentEmailAssert
 body(Matcher<? super Part> matcher) { // NOSONAR | |
| 226 | try { | |
| 227 | String desc = "body of message ${messageIndex}"; | |
| 228 | int msgIdx = this.index; | |
| 229 | for (Message message : actual) { | |
| 230 | final int idx = msgIdx; | |
| 231 |
2
1. lambda$body$1 : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE 2. body : removed call to fr/sii/ogham/testing/assertion/util/AssertionRegistry::register → NO_COVERAGE |
registry.register(() -> assertThat(getBodyPart(message), usingContext(desc, new SingleMessageContext(idx), matcher))); |
| 232 |
1
1. body : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 233 | } | |
| 234 |
1
1. body : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::body → NO_COVERAGE |
return this; |
| 235 | } catch (MessagingException e) { | |
| 236 | throw new AssertionError("Failed to access attachments of messsage", e); | |
| 237 | } | |
| 238 | } | |
| 239 | ||
| 240 | /** | |
| 241 | * Make assertions on the alternative part of the message(s). The | |
| 242 | * alternative is useful when sending HTML email that may be unreadable on | |
| 243 | * some email clients. For example, a smartphone will display the 2 or 3 | |
| 244 | * first lines as a summary. Many smartphones will take the HTML message | |
| 245 | * as-is and will display HTML tags instead of content of email. Alternative | |
| 246 | * is used to provide a textual visualization of the message that will be | |
| 247 | * readable by any system. | |
| 248 | * | |
| 249 | *
 | |
| 250 | * The alternative of the message is either: | |
| 251 | *
 | |
| 252 | *
null if there is only one part
 | |
| 253 | *
null if there is only one text or HTML part
 | |
| 254 | *
the first part if there are more than one text or HTML part
 | |
| 255 | *
 | |
| 256 | * | |
| 257 | *
 | |
| 258 | * .receivedMessages().message(0) | |
| 259 | * .alternative(allOf(notNullValue(), instanceOf(MimeBodyPart.class)) | |
| 260 | *
 | |
| 261 | * | |
| 262 | * Will check if the alternative of the first message is not null and is a | |
| 263 | * MimeBodyPart instance. | |
| 264 | * | |
| 265 | *
 | |
| 266 | * .receivedMessages().every() | |
| 267 | * .alternative(allOf(notNullValue(), instanceOf(MimeBodyPart.class)) | |
| 268 | *
 | |
| 269 | * | |
| 270 | * Will check that the alternative of every message is not null and is a | |
| 271 | * MimeBodyPart instance. | |
| 272 | * | |
| 273 | *
 | |
| 274 | * You can use the {@link #alternative()} variant to make more powerful | |
| 275 | * assertions. | |
| 276 | * | |
| 277 | * @param matcher | |
| 278 | * the assertion to apply on alternative | |
| 279 | * @param <T> | |
| 280 | * the type used for the matcher | |
| 281 | * @return the fluent API for chaining assertions on received message(s) | |
| 282 | */ | |
| 283 | public <T extends Part> FluentEmailAssert
 alternative(Matcher<? super Part> matcher) { // NOSONAR | |
| 284 | try { | |
| 285 | String desc = "alternative of message ${messageIndex}"; | |
| 286 | int msgIdx = this.index; | |
| 287 | for (Message message : actual) { | |
| 288 | final int idx = msgIdx; | |
| 289 |
2
1. alternative : removed call to fr/sii/ogham/testing/assertion/util/AssertionRegistry::register → NO_COVERAGE 2. lambda$alternative$2 : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE |
registry.register(() -> assertThat(getAlternativePart(message), usingContext(desc, new SingleMessageContext(idx), matcher))); |
| 290 |
1
1. alternative : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 291 | } | |
| 292 |
1
1. alternative : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::alternative → NO_COVERAGE |
return this; |
| 293 | } catch (MessagingException e) { | |
| 294 | throw new AssertionError("Failed to access attachments of messsage", e); | |
| 295 | } | |
| 296 | } | |
| 297 | ||
| 298 | /** | |
| 299 | * Make assertions on the sender of the message(s) using fluent API. | |
| 300 | * | |
| 301 | *
 | |
| 302 | * .receivedMessages().message(0).from() | |
| 303 | * .address(hasItems("noreply@sii.fr")) | |
| 304 | * .personal(hasItems("Groupe SII")) | |
| 305 | *
 | |
| 306 | * | |
| 307 | * Will check if the sender email address of the first message is exactly | |
| 308 | *<EMAIL_ADDRESS>and sender displayed address of the first message is | |
| 309 | * exactly "Groupe SII". | |
| 310 | * | |
| 311 | *
 | |
| 312 | * .receivedMessages().every().from() | |
| 313 | * .address(hasItems("noreply@sii.fr")) | |
| 314 | * .personal(hasItems("Groupe SII")) | |
| 315 | *
 | |
| 316 | * | |
| 317 | * Will check if the sender email address of every message is exactly | |
| 318 | *<EMAIL_ADDRESS>and sender displayed address of every message is exactly | |
| 319 | * "Groupe SII". | |
| 320 | * | |
| 321 | * @return the fluent API for chaining assertions on received message(s) | |
| 322 | */ | |
| 323 | public FluentAddressListAssert<FluentEmailAssert
> from() { | |
| 324 | try { | |
| 325 | int msgIdx = this.index; | |
| 326 | List<AddressesWithContext> addresses = new ArrayList<>(); | |
| 327 | for (Message message : actual) { | |
| 328 | addresses.add(new AddressesWithContext(asList((InternetAddress[]) message.getFrom()), "from", new SingleMessageContext(msgIdx))); | |
| 329 |
1
1. from : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 330 | } | |
| 331 |
1
1. from : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::from → NO_COVERAGE |
return new FluentAddressListAssert<>(addresses, this, registry); |
| 332 | } catch (MessagingException e) { | |
| 333 | throw new AssertionError("Failed to get from field of messsage", e); | |
| 334 | } | |
| 335 | } | |
| 336 | ||
| 337 | /** | |
| 338 | * Make assertions on the sender of the message(s) using fluent API. | |
| 339 | * | |
| 340 | *
 | |
| 341 | * .receivedMessages().message(0).to() | |
| 342 | *<EMAIL_ADDRESS>"recipient2@sii.fr")) | |
| 343 | * .personal(hasItems("Foo", "Bar")) | |
| 344 | *
 | |
| 345 | * | |
| 346 | * Will check if the list of email addresses of direct recipients (TO) of | |
| 347 | * the first message are exactly<EMAIL_ADDRESS><EMAIL_ADDRESS>| |
| 348 | * and the list of displayed address of direct recipients (TO) of the first | |
| 349 | * message are exactly "Foo", "Bar". | |
| 350 | * | |
| 351 | *
 | |
| 352 | * .receivedMessages().every().to() | |
| 353 | *<EMAIL_ADDRESS>"recipient2@sii.fr")) | |
| 354 | * .personal(hasItems("Foo", "Bar")) | |
| 355 | *
 | |
| 356 | * | |
| 357 | * Will check if the list of email addresses of direct recipients (TO) of | |
| 358 | * every message are exactly<EMAIL_ADDRESS><EMAIL_ADDRESS>and | |
| 359 | * the list of displayed address of direct recipients (TO) of every message | |
| 360 | * are exactly "Foo", "Bar". | |
| 361 | * | |
| 362 | * @return the fluent API for chaining assertions on received message(s) | |
| 363 | */ | |
| 364 | public FluentAddressListAssert<FluentEmailAssert
> to() { | |
| 365 | try { | |
| 366 | int msgIdx = this.index; | |
| 367 | List<AddressesWithContext> addresses = new ArrayList<>(); | |
| 368 | for (Message message : actual) { | |
| 369 | addresses.add(new AddressesWithContext(asList((InternetAddress[]) message.getRecipients(TO)), "to", new SingleMessageContext(msgIdx))); | |
| 370 |
1
1. to : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 371 | } | |
| 372 |
1
1. to : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::to → NO_COVERAGE |
return new FluentAddressListAssert<>(addresses, this, registry); |
| 373 | } catch (MessagingException e) { | |
| 374 | throw new AssertionError("Failed to get to field of messsage", e); | |
| 375 | } | |
| 376 | } | |
| 377 | ||
| 378 | /** | |
| 379 | * Make assertions on the sender of the message(s) using fluent API. | |
| 380 | * | |
| 381 | *
 | |
| 382 | * .receivedMessages().message(0).cc() | |
| 383 | *<EMAIL_ADDRESS>"recipient2@sii.fr")) | |
| 384 | * .personal(hasItems("Foo", "Bar")) | |
| 385 | *
 | |
| 386 | * | |
| 387 | * Will check if the list of email addresses of copy recipients (CC) of the | |
| 388 | * first message are exactly<EMAIL_ADDRESS><EMAIL_ADDRESS>and | |
| 389 | * the list of displayed address of copy recipients (CC) of the first | |
| 390 | * message are exactly "Foo", "Bar". | |
| 391 | * | |
| 392 | *
 | |
| 393 | * .receivedMessages().every().cc() | |
| 394 | *<EMAIL_ADDRESS>"recipient2@sii.fr")) | |
| 395 | * .personal(hasItems("Foo", "Bar")) | |
| 396 | *
 | |
| 397 | * | |
| 398 | * Will check if the list of email addresses of copy recipients (CC) of | |
| 399 | * every message are exactly<EMAIL_ADDRESS><EMAIL_ADDRESS>and | |
| 400 | * the list of displayed address of copy recipients (CC) of every message | |
| 401 | * are exactly "Foo", "Bar". | |
| 402 | * | |
| 403 | * @return the fluent API for chaining assertions on received message(s) | |
| 404 | */ | |
| 405 | public FluentAddressListAssert<FluentEmailAssert
> cc() { | |
| 406 | try { | |
| 407 | int msgIdx = this.index; | |
| 408 | List<AddressesWithContext> addresses = new ArrayList<>(); | |
| 409 | for (Message message : actual) { | |
| 410 | addresses.add(new AddressesWithContext(asList((InternetAddress[]) message.getRecipients(CC)), "cc", new SingleMessageContext(msgIdx))); | |
| 411 |
1
1. cc : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 412 | } | |
| 413 |
1
1. cc : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::cc → NO_COVERAGE |
return new FluentAddressListAssert<>(addresses, this, registry); |
| 414 | } catch (MessagingException e) { | |
| 415 | throw new AssertionError("Failed to get cc field of messsage", e); | |
| 416 | } | |
| 417 | } | |
| 418 | ||
| 419 | /** | |
| 420 | * Make assertions on the list of attachments of the message(s). | |
| 421 | * | |
| 422 | *
 | |
| 423 | * .receivedMessages().message(0) | |
| 424 | * .attachments(hasSize(1)) | |
| 425 | *
 | |
| 426 | * | |
| 427 | * Will check if the number of attachments of the first message is exactly | |
| 428 | * 1. | |
| 429 | * | |
| 430 | *
 | |
| 431 | * .receivedMessages().every() | |
| 432 | * .attachments(hasSize(1)) | |
| 433 | *
 | |
| 434 | * | |
| 435 | * Will check that the number of attachments of every message is exactly 1. | |
| 436 | * | |
| 437 | *
 | |
| 438 | * You can use the {@link #attachment(String)} or | |
| 439 | * {@link #attachments(Predicate)} variants to make more powerful assertions | |
| 440 | * on a particular attachment. | |
| 441 | * | |
| 442 | * @param matcher | |
| 443 | * the assertion to apply on list of attachments | |
| 444 | * @param <T> | |
| 445 | * the type used for the matcher | |
| 446 | * @return the fluent API for chaining assertions on received message(s) | |
| 447 | */ | |
| 448 | public <T extends Collection<? extends BodyPart>> FluentEmailAssert
 attachments(Matcher<? super Collection<? extends BodyPart>> matcher) { // NOSONAR | |
| 449 | try { | |
| 450 | String desc = "attachments of message ${messageIndex}"; | |
| 451 | int msgIdx = this.index; | |
| 452 | for (Message message : actual) { | |
| 453 | final int idx = msgIdx; | |
| 454 |
2
1. attachments : removed call to fr/sii/ogham/testing/assertion/util/AssertionRegistry::register → NO_COVERAGE 2. lambda$attachments$3 : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE |
registry.register(() -> assertThat(getAttachments(message), usingContext(desc, new SingleMessageContext(idx), matcher))); |
| 455 |
1
1. attachments : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 456 | } | |
| 457 |
1
1. attachments : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachments → NO_COVERAGE |
return this; |
| 458 | } catch (MessagingException e) { | |
| 459 | throw new AssertionError("Failed to access attachments of messsage", e); | |
| 460 | } | |
| 461 | } | |
| 462 | ||
| 463 | /** | |
| 464 | * Make assertions on a particular attachment of the message(s) using fluent | |
| 465 | * API. The attachment is identified by its filename. | |
| 466 | * | |
| 467 | *
 | |
| 468 | * .receivedMessages().message(0).attachment("foo.pdf") | |
| 469 | * .contentType(is("application/pdf")) | |
| 470 | *
 | |
| 471 | * | |
| 472 | * Will check if the content-type of the attachment named "foo.pdf" of the | |
| 473 | * first message is exactly "application/pdf". | |
| 474 | * | |
| 475 | *
 | |
| 476 | * .receivedMessages().every().attachment("foo.pdf") | |
| 477 | * .contentType(is("application/pdf")) | |
| 478 | *
 | |
| 479 | * | |
| 480 | * Will check that the content-type of attachment named "foo.pdf" of every | |
| 481 | * message is exactly "application/pdf". | |
| 482 | * | |
| 483 | *
 | |
| 484 | * This is a shortcut to {@link #attachments(Predicate)} with | |
| 485 | * {@link FileNamePredicate}; | |
| 486 | * | |
| 487 | * @param filename | |
| 488 | * the name of the attachment to make assertions on it | |
| 489 | * @return the fluent API for chaining assertions on received message(s) | |
| 490 | */ | |
| 491 | public FluentPartAssert<FluentEmailAssert
> attachment(String filename) { | |
| 492 |
1
1. attachment : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachment → NO_COVERAGE |
return attachment(By.filename(filename)); |
| 493 | } | |
| 494 | ||
| 495 | /** | |
| 496 | * Make assertions on a particular attachment of the message(s). | |
| 497 | * | |
| 498 | *
 | |
| 499 | * .receivedMessages().message(0).attachment(0) | |
| 500 | * .contentType(is("application/pdf")) | |
| 501 | *
 | |
| 502 | * | |
| 503 | * Will check if the content-type of the first attachment of the first | |
| 504 | * message is exactly "application/pdf". | |
| 505 | * | |
| 506 | *
 | |
| 507 | * .receivedMessages().every().attachment(0) | |
| 508 | * .contentType(is("application/pdf")) | |
| 509 | *
 | |
| 510 | * | |
| 511 | * Will check if the content-type of the first attachment of every message | |
| 512 | * is exactly "application/pdf". | |
| 513 | * | |
| 514 | * @param index | |
| 515 | * the index of the attachment | |
| 516 | * @return the fluent API for chaining assertions on received message(s) | |
| 517 | */ | |
| 518 | public FluentPartAssert<FluentEmailAssert
> attachment(int index) { | |
| 519 | try { | |
| 520 | int msgIndex = this.index; | |
| 521 | List<PartWithContext> attachments = new ArrayList<>(); | |
| 522 | for (Message message : actual) { | |
| 523 | List<BodyPart> found = getAttachments(message); | |
| 524 |
2
1. attachment : changed conditional boundary → NO_COVERAGE 2. attachment : negated conditional → NO_COVERAGE |
BodyPart attachment = index >= found.size() ? null : found.get(index); |
| 525 |
1
1. attachment : negated conditional → NO_COVERAGE |
attachments.add(new PartWithContext(attachment, "attachment with index " + index + (attachment == null ? " (/!\\ not found)" : ""), new SingleMessageContext(msgIndex))); |
| 526 |
1
1. attachment : Changed increment from 1 to -1 → NO_COVERAGE |
msgIndex++; |
| 527 | } | |
| 528 |
1
1. attachment : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachment → NO_COVERAGE |
return new FluentPartAssert<>(attachments, this, registry); |
| 529 | } catch (MessagingException e) { | |
| 530 | throw new AssertionError("Failed to get attachment with index " + index + " of messsage", e); | |
| 531 | } | |
| 532 | } | |
| 533 | ||
| 534 | /** | |
| 535 | * Make assertions on a particular attachment of the message(s) using fluent | |
| 536 | * API. The attachment is identified using the provided finder method. | |
| 537 | * | |
| 538 | *
 | |
| 539 | * If several attachments are found, it fails. If you want to make the same | |
| 540 | * assertions on several attachments at once, use {@link #attachments(By)} | |
| 541 | * instead. | |
| 542 | * | |
| 543 | *
 | |
| 544 | * .receivedMessages().message(0).attachment(By.filename("foo.pdf")) | |
| 545 | * .contentType(is("application/pdf")) | |
| 546 | *
 | |
| 547 | * | |
| 548 | * Will check if the content-type of the attachment named "foo.pdf" of the | |
| 549 | * first message is exactly "application/pdf". | |
| 550 | * | |
| 551 | *
 | |
| 552 | * .receivedMessages().every().attachment(By.filename("foo.pdf")) | |
| 553 | * .contentType(is("application/pdf")) | |
| 554 | *
 | |
| 555 | * | |
| 556 | * Will check that the content-type of attachment named "foo.pdf" of every | |
| 557 | * message is exactly "application/pdf". | |
| 558 | * | |
| 559 | *
 | |
| 560 | * This is a shortcut to {@link #attachments(Predicate)} with | |
| 561 | * {@link FileNamePredicate}; | |
| 562 | * | |
| 563 | * @param by | |
| 564 | * the finder method | |
| 565 | * @return the fluent API for chaining assertions on received message(s) | |
| 566 | */ | |
| 567 | public FluentPartAssert<FluentEmailAssert
> attachment(By by) { | |
| 568 |
1
1. attachment : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachment → NO_COVERAGE |
return attachments(by.toPredicate(), hasSize(lessThanOrEqualTo(1))); |
| 569 | } | |
| 570 | ||
| 571 | /** | |
| 572 | * Make assertions on a one or several attachments of the message(s) using | |
| 573 | * fluent API. The attachments are identified using provided finder method. | |
| 574 | * | |
| 575 | *
 | |
| 576 | * .receivedMessages().message(0) | |
| 577 | * .attachments(By.contentId("cid2")).filename(endsWith(".pdf")) | |
| 578 | *
 | |
| 579 | * | |
| 580 | * Will check if every attachment that have the Content-ID header set to | |
| 581 | * "cid2" of first message has a name ending with ".pdf". | |
| 582 | * | |
| 583 | *
 | |
| 584 | * .receivedMessages().every() | |
| 585 | * .attachments(By.contentId("cid2")).filename(endsWith(".pdf")) | |
| 586 | *
 | |
| 587 | * | |
| 588 | * Will check if every attachment that have the Content-ID header set to | |
| 589 | * "cid2" of every messages has a name ending with ".pdf". | |
| 590 | * | |
| 591 | * | |
| 592 | * @param by | |
| 593 | * the finder method | |
| 594 | * @return the fluent API for chaining assertions on received message(s) | |
| 595 | */ | |
| 596 | public FluentPartAssert<FluentEmailAssert
> attachments(By by) { | |
| 597 |
1
1. attachments : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachments → NO_COVERAGE |
return attachments(by.toPredicate()); |
| 598 | } | |
| 599 | ||
| 600 | /** | |
| 601 | * Make assertions on a one or several attachments of the message(s) using | |
| 602 | * fluent API. The attachments are identified using provided predicate. | |
| 603 | * | |
| 604 | *
 | |
| 605 | * .receivedMessages().message(0) | |
| 606 | * .attachments(new PdfFilter()).filename(endsWith(".pdf")) | |
| 607 | *
 | |
| 608 | * | |
| 609 | * Will check if the name of every PDF attachments of the first message are | |
| 610 | * named "foo.pdf". | |
| 611 | * | |
| 612 | *
 | |
| 613 | * .receivedMessages().every() | |
| 614 | * .attachments(new PdfFilter()).filename(endsWith(".pdf")) | |
| 615 | *
 | |
| 616 | * | |
| 617 | * Will check if the name of every PDF attachments of every message are | |
| 618 | * named "foo.pdf". | |
| 619 | * | |
| 620 | * | |
| 621 | * @param filter | |
| 622 | * the filter used to find attachments | |
| 623 | * @return the fluent API for chaining assertions on received message(s) | |
| 624 | */ | |
| 625 | public FluentPartAssert<FluentEmailAssert
> attachments(Predicate<Part> filter) { | |
| 626 |
1
1. attachments : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachments → NO_COVERAGE |
return attachments(filter, null); |
| 627 | } | |
| 628 | | |
| 629 | private FluentPartAssert<FluentEmailAssert
> attachments(Predicate<Part> filter, Matcher<? super Collection<? extends Part>> singleMessageAttachmentsMatcher) { | |
| 630 | try { | |
| 631 | int msgIdx = this.index; | |
| 632 | List<PartWithContext> attachments = new ArrayList<>(); | |
| 633 | for (Message message : actual) { | |
| 634 | int matchingIdx = 0; | |
| 635 | boolean noneFound = true; | |
| 636 | List<Part> matchingAttachmentsForMessage = EmailUtils.<Part> getAttachments(message, filter); | |
| 637 |
1
1. attachments : removed call to fr/sii/ogham/testing/assertion/email/FluentEmailAssert::checkFoundAttachmentPerMessage → NO_COVERAGE |
checkFoundAttachmentPerMessage(filter, singleMessageAttachmentsMatcher, msgIdx, matchingAttachmentsForMessage); |
| 638 |
1
1. attachments : removed call to fr/sii/ogham/testing/assertion/email/FluentEmailAssert::contextualize → NO_COVERAGE |
contextualize(filter, msgIdx, attachments, matchingIdx, noneFound, matchingAttachmentsForMessage); |
| 639 |
1
1. attachments : Changed increment from 1 to -1 → NO_COVERAGE |
msgIdx++; |
| 640 | } | |
| 641 |
1
1. attachments : replaced return value with null for fr/sii/ogham/testing/assertion/email/FluentEmailAssert::attachments → NO_COVERAGE |
return new FluentPartAssert<>(attachments, this, registry); |
| 642 | } catch (MessagingException e) { | |
| 643 | throw new AssertionError("Failed to get attachment " + filter + " of messsage", e); | |
| 644 | } | |
| 645 | } | |
| 646 | ||
| 647 | private static void contextualize(Predicate<Part> filter, int msgIdx, List<PartWithContext> attachments, int matchingIdx, boolean noneFound, List<Part> matchingAttachmentsForMessage) { | |
| 648 | for (Part attachment : matchingAttachmentsForMessage) { | |
| 649 | noneFound = false; | |
| 650 | attachments.add(new PartWithContext(attachment, "attachment " + filter + " (matching index: " + matchingIdx + ")", new SingleMessageContext(msgIdx))); | |
| 651 |
1
1. contextualize : Changed increment from 1 to -1 → NO_COVERAGE |
matchingIdx++; |
| 652 | } | |
| 653 |
1
1. contextualize : negated conditional → NO_COVERAGE |
if (noneFound) { |
| 654 | attachments.add(new PartWithContext(null, "attachment " + filter + " (/!\\ not found)", new SingleMessageContext(msgIdx))); | |
| 655 | } | |
| 656 | } | |
| 657 | ||
| 658 | private void checkFoundAttachmentPerMessage(Predicate<Part> filter, Matcher<? super Collection<? extends Part>> singleMessageAttachmentsMatcher, int msgIdx, | |
| 659 | List<Part> matchingAttachmentsForMessage) { | |
| 660 |
1
1. checkFoundAttachmentPerMessage : negated conditional → NO_COVERAGE |
if (singleMessageAttachmentsMatcher != null) { |
| 661 |
2
1. checkFoundAttachmentPerMessage : removed call to fr/sii/ogham/testing/assertion/util/AssertionRegistry::register → NO_COVERAGE 2. lambda$checkFoundAttachmentPerMessage$4 : removed call to fr/sii/ogham/testing/assertion/util/AssertionHelper::assertThat → NO_COVERAGE |
registry.register(() -> assertThat("message "+msgIdx+" should have only one attachment "+filter, matchingAttachmentsForMessage, singleMessageAttachmentsMatcher)); |
| 662 | } | |
| 663 | } | |
| 664 | } | |
Mutations | ||
| 84 |
1.1 2.2 |
|
| 85 |
1.1 |
|
| 87 |
1.1 |
|
| 130 |
1.1 |
|
| 132 |
1.1 |
|
| 181 |
1.1 |
|
| 183 |
1.1 |
|
| 231 |
1.1 2.2 |
|
| 232 |
1.1 |
|
| 234 |
1.1 |
|
| 289 |
1.1 2.2 |
|
| 290 |
1.1 |
|
| 292 |
1.1 |
|
| 329 |
1.1 |
|
| 331 |
1.1 |
|
| 370 |
1.1 |
|
| 372 |
1.1 |
|
| 411 |
1.1 |
|
| 413 |
1.1 |
|
| 454 |
1.1 2.2 |
|
| 455 |
1.1 |
|
| 457 |
1.1 |
|
| 492 |
1.1 |
|
| 524 |
1.1 2.2 |
|
| 525 |
1.1 |
|
| 526 |
1.1 |
|
| 528 |
1.1 |
|
| 568 |
1.1 |
|
| 597 |
1.1 |
|
| 626 |
1.1 |
|
| 637 |
1.1 |
|
| 638 |
1.1 |
|
| 639 |
1.1 |
|
| 641 |
1.1 |
|
| 651 |
1.1 |
|
| 653 |
1.1 |
|
| 660 |
1.1 |
|
| 661 |
1.1 2.2 |


Toggle navigation
Mentor TV
What's New?
Weekly Ad
Products
Audio
Video
Furniture
Services
Flat-Panel TV Installation
Home Theater Installation
Home Network Installation
Outdoor Speaker Installation
Service Department
About Us
Contact Us
Previous
Next
Mentor TV's Weekly In-Store Ad & Specials For 7-30-17 thru 8-5-17 (
Click here for PDF version
)


You gain one additional Tag skill, which must be one of Energy Weapons, Science, or Repair.
As a member of the Brotherhood of Steel, you are bound by the chain of command: The Chain that Binds. You must carry out the orders of your immediate superiors, and you are responsible for your subordinate siblings. If you do not carry out your duty, you are expelled from the Brotherhood and your technology will be reclaimed—by any means necessary.
You are immune to radiation damage. In fact, you’re healed by it—you regain 1 HP for every 3 points of radiation damage inflicted upon you, and if you rest in an irradiated location, you may re-roll your dice pool when checking if your injuries heal. In addition, Survival becomes a Tag skill, increasing it by 2 ranks.
You age at a much-decreased rate, and you’re probably older than your unmutated companions—you may even have survived the Great War of 2077—but you’re sterile: “the first generation of ghouls is the last” as the saying goes. You may face discrimination from “smoothskins” (humans who aren’t ghouls), increasing the difficulty or complication range of Charisma tests depending on your opponent’s beliefs.
Your initial Strength and Endurance attributes are increased by +2 each, and your maximum Strength and Endurance are increased to 12, but your maximum Intelligence and Charisma are both reduced to 6. You may not have more than 4 ranks in any skill. You are completely immune to radiation and poison damage.
You stand over seven feet tall, and your body is bulky and muscular. Your skin is green, yellow, or grey, regardless of what color it was when you were human. You do not seem to age, but you are sterile.
You can only wear armor which has been made to fit a super mutant.
You have 360° vision and improved sensory systems that can detect smells, chemicals, and radiation, reducing the difficulty of Perception tests that rely on sight and smell by 1. You are also immune to radiation and poison damage, but you cannot use chems, nor can you benefit from food, drink, or rest. You move by jet propulsion, hovering above the ground, unaffected by difficult terrain or obstacles. Your carry weight is 150 lbs., and it cannot be increased by your Strength or perks, but it can be increased by modi- fied armor. You cannot recover from your own injuries or heal health points without receiving repairs (see Healing Robots, p.34).
You cannot manipulate the physical world like humans do, instead you have three of the arm attachments in the Arm Attachments table, determined by your choice of equipment pack. If you select an arm that features a weapon, you also gain 20 shots of ammo for that weapon.
You may choose two of the following traits, or one trait and one additional perk. Each trait has a benefit and may have an accompanying penalty.
Your healthier start to life at the hands of trained doctors and sophisticated auto-docs means you reduce the difficulty of all END tests to resist the effects of disease. In addition, your carefully-planned upbringing means you have one additional tag skill of your choice.
You may also work with the Gamemaster to determine what sort of experiment took place within your Vault. Once per quest, the GM may introduce a complication which reflects the nature of the experiment you unwittingly took part in, or introduce a complication related to your early life of isola- tion and confinement within the Vault. If the GM does this, you immediately regain one Luck Point.
| Name | Tag | Points | Rank |
|---|---|---|---|
| [STR] | yes | ||
| [CHA] | yes | ||
| [END] | yes | ||
| [PER] | yes | ||
| [PER] | yes | ||
| [PER] | yes | ||
| [INT] | yes | ||
| [STR] | yes | ||
| [PER] | yes | ||
| [INT] | yes | ||
| [INT] | yes | ||
| [AGI] | yes | ||
| [AGI] | yes | ||
| [CHA] | yes | ||
| [END] | yes | ||
| [AGI] | yes | ||
| [STR] | yes |
None 1 2 3
Casual clothing, 1 Buffout
4 +2 shots of flamer fuel
4 +2 throwing knives or 2 +1 tomahawks
| Name | Stat | Tag | Rank |
|---|---|---|---|
| STR | |||
| CHA | |||
| END | |||
| PER | |||
| PER | |||
| PER | |||
| INT | |||
| STR | |||
| PER | |||
| INT | |||
| INT | |||
| AGI | |||
| AGI | |||
| CHA | |||
| END | |||
| AGI | |||
| STR |
| Head (1-2) | |||
|---|---|---|---|
| Name | Rank | Effect |
|---|---|---|


Super Junior’s Shindong updates progress in weight loss journey
- Advertisement -
South Korean K-pop band Super Junior’s Shindong just recently updated the progress on his weight loss journey.
At the end of last month, Shindong revealed that he would be focusing on losing weight for health reasons.
He had lost 17 kilograms, going from a starting weight of 116 kilograms to 99 kilograms.
The reason he decided to lose weight was to stay healthy and continue his career as a member of Super Junior.
- Advertisement -
Shindong had been suffering from continued yo-yo weight fluctuations from trying out different diets.
He also said that he has been finding it tough to dance on stage because of his overall level of physical activity had decreased.
Inspired by Yoo Jae Hwan who recently lost 32 kilograms, Shindong followed the same program because he needed to find a healthier way to lose weight.
The Super Junior member shared that he has been on a lot of diets, so many that he could say that he tried them all.
Due to weight fluctuations, he was recently at his heaviest and he wasn’t sure if he could lose weight on his own so he sought professional help.
Shindong said he has been eating a balanced diet with three meals a day and seeing the weight fall off even without exercise.
That’s when he realised why he had been failing at his other diets. Through AI analysis, Shindong was able to understand the state of his body and get professional consulting.
He added that it’s so interesting and fun to watch his health improve through data.
Shindong also joked that his stylist is having a tough time finding new clothes for him as he’s gotten slimmer and his old clothes don’t.
The singer also feels more energetic and is enjoying more when he’s dancing on stage.
Sharing photos of his progress on his Instagram account, he wrote that it’s not over and he is not even halfway there.
- Advertisement -


This is git-sitemap test with Travis CI!
sitemap.xml is generated automatically by git-sitemap when Travis CI detect new commits.


Configure Jenkins to monitor an Amazon SQS queue for messages. Jenkins will start a new build
if a message is posted to the queue and the message's content matches this job's repository and
branch. The repository should be set up to post messages to the queue whenever changes are made.
Available queues can be configured in the System Configuration of
Jenkins.
Further documentation is available in the
SCM SQS Plugin repository on GitHub.


--- sort_order: 101 tei_id: rdx_b6zxc.p.idm149254912 annotation_count: 0 images: small-thumbnail: https://readux.ecds.emory.edu/books/emory:b6zxc/pages/emory:h6wv2/mini-thumbnail/ json: https://readux.ecds.emory.edu/books/emory:b6zxc/pages/emory:h6wv2/info/ full: https://readux.ecds.emory.edu/books/emory:b6zxc/pages/emory:h6wv2/fs/ page: https://readux.ecds.emory.edu/books/emory:b6zxc/pages/emory:h6wv2/single-page/ thumbnail: https://readux.ecds.emory.edu/books/emory:b6zxc/pages/emory:h6wv2/thumbnail/ title: Page 97 number: 97 permalink: "/pages/97/" ---


A great use for a mixin is to take redundant CSS3 with multiple vendor prefixes and create a snippet of CSS rules that can be reused.


Shanghai Disney Holiday is a world-class family entertainment destination specially designed and built for Chinese tourists. Shanghai Oriental Pearl TV Tower, Oriental Pearl is located on the banks of the Huangpu River in Shanghai and at the tip of Lujiazui in Pudong, showing the spectacular scenery of Shanghai as an international metropolis. Third, the Bund is a walking sightseeing belt between Baidu Bridge and Jinling East Road on the West Bank of the Huangpu River in the center of Shanghai. It is one of the most symbolic attractions in Shanghai. The architectural complexes and Pujiang night scenes are the most attractive places here. Landscape. Fourth, Nanjing Road pedestrian street, about 1200 meters long, a glance, modern buildings mixed with the European old building, especially under the neon lights flashing, there is no style.


Team Roster
Jared
Manager
ID:
1
Email:
<EMAIL_ADDRESS>Office:
1
Alec
Engineer
ID:
2
Email:
<EMAIL_ADDRESS>GitHub:
AlecTheCoder
Grace
Engineer
ID:
3
Email:
<EMAIL_ADDRESS>GitHub:
GraceTheCoder
Tammer
Engineer
ID:
4
Email:
<EMAIL_ADDRESS>GitHub:
TammerTheCoder
John
Intern
ID:
5
Email:
<EMAIL_ADDRESS>School:
The University


public class Vector3f
extends java.lang.Object
This class implements the basic functionality for a 3D vector required for rendering and 3D graphics use. This class is patterned after and most code adapted from the CUnitV3f class of the JOEY toolkit written and distributed by Crisis in Perspective, Inc.
| Modifier and Type | Field and Description |
|---|---|
float |
i
The I component of the vector.
|
float |
j
The J component of the vector.
|
float |
k
The K component of the vector.
|
Vector3f |
m_next
A pointer to tne next Vector3f in a cache if this object is cached.
|
| Constructor and Description |
|---|
Vector3f()
Creates a new instance of Vector3f.
|
Vector3f(float i,
float j,
float k)
Creates a new instance of Vector3f with the I, J, and K components
set as specified.
|
Vector3f(Point3f ptOrg,
Point3f ptThru)
Creates a new instance of Vector3f initialized to be a vector from ptOrg to
ptThru.
|
Vector3f(Vector3f v)
Creates a new instance of Vector3f set equal to another vector.
|
| Modifier and Type | Method and Description |
|---|---|
Vector3f |
add(Vector3f v)
Adds a vector, v, to this vector.
|
java.lang.Object |
clone()
Clone this vector.
|
Vector3f |
cloneVector3f()
Clone this vector.
|
Vector3f |
cross(Vector3f v)
Cross this vector with another vector, v.
|
float |
dot(Vector3f v)
Gets the dot product between this vector and another vector, v.
|
boolean |
equals(java.lang.Object obj)
Tests another object, obj, for equality with this vector.
|
boolean |
equals(Vector3f v)
Tests another vector, v, for equality with this vector.
|
float |
getLength()
Get the length of this vector.
|
Vector3f |
normalize()
Normalize this vector - in other words, scale the vector so its length is equal to 1 and it can
be used as a direction vector.
|
Vector3f |
reverse()
Reverse the direction of this vector.
|
Vector3f |
scale(float fScale)
Scale a vector - multiply each of its components by a scaling factor.
|
boolean |
setToHt(Vector3f vL,
Vector3f vT,
float ni,
float nt)
Compute the microfacet surface normal, Ht, that would be required to refract light from the L direction
in the T direction.
|
Vector3f |
setToReflection(Vector3f vNormal,
Vector3f vFrom)
Sets this vector to the the reflection of the vFrom vector around the surface normal,
vNormal.
|
boolean |
setToRefraction(Vector3f vNormal,
Vector3f vFrom,
float fN_in,
float fN_out)
Sets this vector to the the refraction of the vFrom vector at the surface
given by the normal vNormal.
|
Vector3f |
setValue(float i,
float j,
float k)
Sets the I, J, and K components as specified.
|
Vector3f |
setValue(Point3f ptOrg,
Point3f ptThru)
Sets the value of the vector to be a vector from ptOrg to ptThru.
|
Vector3f |
setValue(Vector3f v)
Sets the value of this vector (each of the components) to be equal to some other vector, v.
|
Vector3f |
subtract(Vector3f v)
Subtracts a vector, v, from this vector.
|
public Vector3f m_next
public float i
public float j
public float k
public Vector3f()
public Vector3f(float i, float j, float k)
i
- The I component of the vector.j
- The J component of the vector.k
- The K component of the vector.public Vector3f(Vector3f v)
v
- The vector to make this new vector equal to.public Vector3f(Point3f ptOrg, Point3f ptThru)
ptOrg
- The start of the vector.ptThru
- The end of the vector.public Vector3f setValue(float i, float j, float k)
i
- The I component of the vector.j
- The J component of the vector.k
- The K component of the vector.public Vector3f setValue(Point3f ptOrg, Point3f ptThru)
ptOrg
- The start of the vector.ptThru
- The end of the vector.public Vector3f setValue(Vector3f v)
v
- The vector to make this vector equal to. The value of this vector is unchanged.public Vector3f reverse()
public float dot(Vector3f v)
v
- The vector against which we take the dot product. The value of this vector is unchanged.public Vector3f add(Vector3f v)
v
- The vector to be added to this vector. The value of this vector is unchanged.public Vector3f subtract(Vector3f v)
v
- The vector to be subtracted from this vector. The value of this vector is unchanged.public Vector3f cross(Vector3f v)
v
- The vector to be crossed with this vector. The value of this vector is unchanged.public Vector3f setToReflection(Vector3f vNormal, Vector3f vFrom) throws ZeroLengthVectorException
This computation is performed as described in Illumination and Color in Computer Generated Imagery by Roy Hall, Appendix III.1 Geometry utilities.
Although the math should produce a normalized vector if the input vectors are normalized, the reflection vector is re-normalized after computation to minimize the buildup of round off errors.
vNormal
- The surface normal. The value of this vector is unchanged.vFrom
- The vector from the surface to be reflected about the normal. The value of this vector is unchanged.ZeroLengthVectorException
public boolean setToRefraction(Vector3f vNormal, Vector3f vFrom, float fN_in, float fN_out)
This computation is performed as described in Illumination and Color in Computer Generated Imagery by Roy Hall, Appendix III.1 Geometry utilities.
vNormal
- The surface normal. The value of this vector is unchanged.vFrom
- The vector from the surface for which we want the refraction (by convention, all
vectors are from the surface when the computations are made). The value of this vector is unchanged.fN_in
- The index of refraction of the material the vFrom vector is
traveling through.fN_out
- The index of refraction of the material the refracted vector will be traveling
through.public boolean setToHt(Vector3f vL, Vector3f vT, float ni, float nt)
vL
- The light vector, LvT
- The transmitted direction, Tni
- The index of refraction for Lnt
- The index of refraction for Tpublic float getLength()
public Vector3f normalize() throws ZeroLengthVectorException
ZeroLengthVectorException
- The exception is thrown when the length of the vector is eoo close to zero that
normalizing the vector returns a meaningless result.public Vector3f scale(float fScale)
fScale
- The scaling factor.public boolean equals(Vector3f v)
v
- The vector to be tested. This vector is unchanged.public boolean equals(java.lang.Object obj)
equals
in class java.lang.Object
obj
- The object to be tested. This object is unchanged.public java.lang.Object clone()
clone
in class java.lang.Object
public Vector3f cloneVector3f()


Impressum
Legal Disclosure
Information in accordance with Section 5 TMG
Tieckstr. 40
c/o Olga Maslovskaya
10115 Berlin
Represented by
Jakob Graff, Olga Maslovskaya, Noa Tamir
Contact Information
Telephone: +4917647697674
E-Mail:
<EMAIL_ADDRESS>address:
https://berlin2019.satrdays.org/
Register entry
Entry in: Vereinsregister
Register Number: VR 37258 B
Register Court: Amtsgericht Charlottenburg
Disclaimer
Accountability for content
The contents of our pages have been created with the utmost care. However, we cannot guarantee the contents'
accuracy, completeness or topicality. According to statutory provisions, we are furthermore responsible for
our own content on these web pages. In this matter, please note that we are not obliged to monitor
the transmitted or saved information of third parties, or investigate circumstances pointing to illegal activity.
Our obligations to remove or block the use of information under generally applicable laws remain unaffected by this as per
§§ 8 to 10 of the Telemedia Act (TMG).
Accountability for links
Responsibility for the content of
external links (to web pages of third parties) lies solely with the operators of the linked pages. No violations were
evident to us at the time of linking. Should any legal infringement become known to us, we will remove the respective
link immediately.
Copyright
Our web pages and their contents are subject to German copyright law. Unless
expressly permitted by law, every form of utilizing, reproducing or processing
works subject to copyright protection on our web pages requires the prior consent of the respective owner of the rights.
Individual reproductions of a work are only allowed for private use.
The materials from these pages are copyrighted and any unauthorized use may violate copyright laws.
Quelle: translate-24h Englisch Übersetzungen
{{ if .Site.Params.footer.enable }}
{{ partial "footer.html" . }}
{{ end }}
{{ if .Site.Params.portfolio.enable }}
{{ partial "modals.html" . }}
{{ end }}
{{ partial "js.html" . }}


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | package org.apache.commons.collections4.map; | |
| 18 | ||
| 19 | import java.io.IOException; | |
| 20 | import java.io.ObjectInputStream; | |
| 21 | import java.io.ObjectOutputStream; | |
| 22 | import java.io.Serializable; | |
| 23 | import java.util.Map; | |
| 24 | ||
| 25 | /** | |
| 26 | * A case-insensitive Map. | |
| 27 | *
 | |
| 28 | * Before keys are added to the map or compared to other existing keys, they are converted | |
| 29 | * to all lowercase in a locale-independent fashion by using information from the Unicode | |
| 30 | * data file. | |
| 31 | *
 | |
| 32 | * Null keys are supported. | |
| 33 | *
 | |
| 34 | * The keySet() method returns all lowercase keys, or nulls. | |
| 35 | *
 | |
| 36 | * Example: | |
| 37 | *
 | |
| 38 | * Map<String, String> map = new CaseInsensitiveMap<String, String>(); | |
| 39 | * map.put("One", "One"); | |
| 40 | * map.put("Two", "Two"); | |
| 41 | * map.put(null, "Three"); | |
| 42 | * map.put("one", "Four"); | |
| 43 | *
 | |
| 44 | * creates a CaseInsensitiveMap with three entries.
 | |
| 45 | * map.get(null) returns "Three" and map.get("ONE") | |
| 46 | * returns "Four". The Set returned by keySet() | |
| 47 | * equals {"one", "two", null}. | |
| 48 | *
 | |
| 49 | * This map will violate the detail of various Map and map view contracts.</note> | |
| 50 | * As a general rule, don't compare this map to other maps. In particular, you can't | |
| 51 | * use decorators like {@link ListOrderedMap} on it, which silently assume that these | |
| 52 | * contracts are fulfilled. | |
| 53 | *
 | |
| 54 | * Note that CaseInsensitiveMap is not synchronized and is not thread-safe. | |
| 55 | * If you wish to use this map from multiple threads concurrently, you must use | |
| 56 | * appropriate synchronization. The simplest approach is to wrap this map | |
| 57 | * using {@link java.util.Collections#synchronizedMap(Map)}. This class may throw | |
| 58 | * exceptions when accessed by concurrent threads without synchronization. | |
| 59 | * | |
| 60 | * @since 3.0 | |
| 61 | * @version $Id: CaseInsensitiveMap.java 1533984 2013-10-20 21:12:51Z tn $ | |
| 62 | */ | |
| 63 | public class CaseInsensitiveMap<K, V> extends AbstractHashedMap<K, V> implements Serializable, Cloneable { | |
| 64 | ||
| 65 | /** Serialisation version */ | |
| 66 | private static final long serialVersionUID = -7074655917369299456L; | |
| 67 | ||
| 68 | /** | |
| 69 | * Constructs a new empty map with default size and load factor. | |
| 70 | */ | |
| 71 | public CaseInsensitiveMap() { | |
| 72 | super(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_THRESHOLD); | |
| 73 | } | |
| 74 | ||
| 75 | /** | |
| 76 | * Constructs a new, empty map with the specified initial capacity. | |
| 77 | * | |
| 78 | * @param initialCapacity the initial capacity | |
| 79 | * @throws IllegalArgumentException if the initial capacity is negative | |
| 80 | */ | |
| 81 | public CaseInsensitiveMap(final int initialCapacity) { | |
| 82 | super(initialCapacity); | |
| 83 | } | |
| 84 | ||
| 85 | /** | |
| 86 | * Constructs a new, empty map with the specified initial capacity and | |
| 87 | * load factor. | |
| 88 | * | |
| 89 | * @param initialCapacity the initial capacity | |
| 90 | * @param loadFactor the load factor | |
| 91 | * @throws IllegalArgumentException if the initial capacity is negative | |
| 92 | * @throws IllegalArgumentException if the load factor is less than zero | |
| 93 | */ | |
| 94 | public CaseInsensitiveMap(final int initialCapacity, final float loadFactor) { | |
| 95 | super(initialCapacity, loadFactor); | |
| 96 | } | |
| 97 | ||
| 98 | /** | |
| 99 | * Constructor copying elements from another map. | |
| 100 | *
 | |
| 101 | * Keys will be converted to lower case strings, which may cause | |
| 102 | * some entries to be removed (if string representation of keys differ | |
| 103 | * only by character case). | |
| 104 | * | |
| 105 | * @param map the map to copy | |
| 106 | * @throws NullPointerException if the map is null | |
| 107 | */ | |
| 108 | public CaseInsensitiveMap(final Map<? extends K, ? extends V> map) { | |
| 109 | super(map); | |
| 110 | } | |
| 111 | ||
| 112 | //----------------------------------------------------------------------- | |
| 113 | /** | |
| 114 | * Overrides convertKey() from {@link AbstractHashedMap} to convert keys to | |
| 115 | * lower case. | |
| 116 | *
 | |
| 117 | * Returns {@link AbstractHashedMap#NULL} if key is null. | |
| 118 | * | |
| 119 | * @param key the key convert | |
| 120 | * @return the converted key | |
| 121 | */ | |
| 122 | @Override | |
| 123 | protected Object convertKey(final Object key) { | |
| 124 |
1
1. convertKey : negated conditional → NO_COVERAGE |
if (key != null) { |
| 125 | final char[] chars = key.toString().toCharArray(); | |
| 126 |
4
1. convertKey : changed conditional boundary → NO_COVERAGE 2. convertKey : Changed increment from -1 to 1 → NO_COVERAGE 3. convertKey : Replaced integer subtraction with addition → NO_COVERAGE 4. convertKey : negated conditional → NO_COVERAGE |
for (int i = chars.length - 1; i >= 0; i--) { |
| 127 | chars[i] = Character.toLowerCase(Character.toUpperCase(chars[i])); | |
| 128 | } | |
| 129 |
1
1. convertKey : mutated return of Object value for org/apache/commons/collections4/map/CaseInsensitiveMap::convertKey to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new String(chars); |
| 130 | } | |
| 131 |
1
1. convertKey : mutated return of Object value for org/apache/commons/collections4/map/CaseInsensitiveMap::convertKey to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return AbstractHashedMap.NULL; |
| 132 | } | |
| 133 | ||
| 134 | //----------------------------------------------------------------------- | |
| 135 | /** | |
| 136 | * Clones the map without cloning the keys or values. | |
| 137 | * | |
| 138 | * @return a shallow clone | |
| 139 | */ | |
| 140 | @Override | |
| 141 | public CaseInsensitiveMap<K, V> clone() { | |
| 142 |
1
1. clone : mutated return of Object value for org/apache/commons/collections4/map/CaseInsensitiveMap::clone to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return (CaseInsensitiveMap<K, V>) super.clone(); |
| 143 | } | |
| 144 | ||
| 145 | /** | |
| 146 | * Write the map out using a custom routine. | |
| 147 | */ | |
| 148 | private void writeObject(final ObjectOutputStream out) throws IOException { | |
| 149 |
1
1. writeObject : removed call to java/io/ObjectOutputStream::defaultWriteObject → NO_COVERAGE |
out.defaultWriteObject(); |
| 150 |
1
1. writeObject : removed call to org/apache/commons/collections4/map/CaseInsensitiveMap::doWriteObject → NO_COVERAGE |
doWriteObject(out); |
| 151 | } | |
| 152 | ||
| 153 | /** | |
| 154 | * Read the map in using a custom routine. | |
| 155 | */ | |
| 156 | private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { | |
| 157 |
1
1. readObject : removed call to java/io/ObjectInputStream::defaultReadObject → NO_COVERAGE |
in.defaultReadObject(); |
| 158 |
1
1. readObject : removed call to org/apache/commons/collections4/map/CaseInsensitiveMap::doReadObject → NO_COVERAGE |
doReadObject(in); |
| 159 | } | |
| 160 | ||
| 161 | } | |
Mutations | ||
| 124 |
1.1 |
|
| 126 |
1.1 2.2 3.3 4.4 |
|
| 129 |
1.1 |
|
| 131 |
1.1 |
|
| 142 |
1.1 |
|
| 149 |
1.1 |
|
| 150 |
1.1 |
|
| 157 |
1.1 |
|
| 158 |
1.1 |


Michail Schwab, Hendrik Strobelt, James Tompkin, Colin Fredericks, Connor Huff, Dana Higgins, Anton Strezhnev, Mayya Komisarchik, Gary King and Hanspeter Pfister
Information hierarchies are difficult to express when real-world space or time constraints force traversing the hierarchy in linear presentations, such as in educational books and classroom courses. We present booc.io, which allows linear and non-linear presentation and navigation of educational concepts and material. To support a breadth of material for each concept, booc.io is Web based, which allows adding material such as lecture slides, book chapters, videos, and LTIs. A visual interface assists the creation of the needed hierarchical structures. The goals of our system were formed in expert interviews, and we explain how our design meets these goals. We adapt a real-world course into booc.io, and perform introductory qualitative evaluation with students.


{% load staticfiles %} {% block page_head %} {% endblock %}
Dearest,
{{party.name}} {% endif%}
Together with our parents, we invite you to share our joy, as we exchange vows and celebrate our marriage.


Hey, my blog is now online.
Things are almost done.
If published tonight, it would be my first article blogged here. The implementation of this blog contains many things I feel good and useful, and I might later write articles about the techniques I have used here.
What I might write
Images — figures, zooming & captions
Left is a demo image (the same as the one used as header background). Image zooming is fast and fluid, and you can try to zoom it in and out.
There’re 4 different kinds of figures, but the one demonstrated is only one of the four.
Typography
How to use @font-face
to correctly refer to local fonts,
and how the font-feature-settings
CSS property works
— which I am not myself clear about.
What’s yet to be done
I am going to place a share button in article pages.
I would also have to manually maintain every page, and have no plan to generate the pages automatically yet.


Hey, there. Thank you for requesting access to aKoma. Watch out for a follow up email when your access is activated. If you have any questions, feel free to contact us at<EMAIL_ADDRESS>Later. The aKoma Squad


I would like to introduce how to push local repository. When you implemented some functions, you push them to remote repository. (We push on Wednesday.)
- Checkout the develop branch If you are in the master branch, checkout the develop branch. If you have not created the develop branch yet, create it and checkout.
- Add the files Add the files which you want to push to prepare the content staged for the next commit. After you added, if you want to cancel the staged files, you can cancel. These operation is easy. Just drag-and-drop.
- Commit your changes Commit save your changes to the local repository. you save the staged files by add operation.
- Push the develop branch After commit, you push it.
How to create branch
You commit with message about your change.
How to cancel the commit
If you want to cancel the commit you can do it. First, click the "Log / History". Then hover the cursor on the before your commit and right click. Finally, choose the "Restet current branch to this commit".After reset
Check your develop branch and push.


All Classes
Main
RatingsEdgeApi
RatingsEdgeApiOriginFilter
RatingsEdgeApiResponseMessage
RatingsEdgeApiService
RatingsEdgeApiServiceFactory
RatingsEdgeApiServiceImpl
RatingsEdgeService
RatingsEdgeServiceTest
RatingsEdgeSessionToken
TestConstants


A class went to a school trip. And, as usually, all N kids have got their backpacks stuffed with candy. But soon quarrels started all over the place, as some of the kids had more candies than others. Soon, the teacher realized that he has to step in: "Everybody, listen! Put all the candies you have on this table here!"
Soon, there was quite a large heap of candies on the teacher's table. "Now, I will divide the candies into N equal heaps and everyone will get one of them." announced the teacher.
"Wait, is this really possible?" wondered some of the smarter kids.
You are given the number of candies each child brought. Find out whether the teacher can divide the candies into N exactly equal heaps. (For the purpose of this task, all candies are of the same type.)
The first line of the input file contains an integer T specifying the number of test cases. Each test case is preceded by a blank line.
Each test case looks as follows: The first line contains N : the number of children. Each of the next N lines contains the number of candies one child brought.
For each of the test cases output a single line with a single word "YES" if the candies can be distributed equally, or "NO" otherwise.
Input: 2 5 5 2 7 3 8 6 7 11 2 7 3 4 Output: YES NONote: the input file will not exceed 1MB.


--- layout: post title: "My Week in Review" date: 2019-11-03 23:00:00 +0000 image: https://s3.amazonaws.com/audreywatters/2016-04-17-pelican.jpg imagecredits: https://www.flickr.com/photos/levork/4383465477 ---
I’ve been working this week on the “Afterword,” which is perhaps an indulgent sort of chapter to have, but whatever.
HEWN, No. 328 via substack.com
I chatted with Amy Chapman about a project she’s working on regarding women and ed-tech.
It’s not “work”; it’s democracy. But I voted. I also made a few end-of-the-month changes to my websites. And I signed a bunch of paperwork for the sale of land in Texas that apparently my brother and I inherited.
I’m in currently New Orleans, and I’m writing this on a very full stomach of oysters and po’boy. Upcoming week: Here, then home.
I read Joanne McNeil’s Lurking: How a Person Became a User on the flight to NOLA.
Icon credits: The Noun Project


General Considerations¶
Inside the code are four different objects that ties the different moduels together. The basisset obejct “basis”, the inputfile object “input”, the settingsfile object “settings” and the results object “results”.
Basisset object¶
The basisset object is a list of list with the following structure:
Idx is the AO index. Atomidx, is the index of the associated atom. #CONTR contains the number of primitive functions in the contracted.
CONTR contains all the information about the primitive functions and have the form:
Inside the integral call, the basisset file is reconstructed into three different arrays, containing the basisset information. The first one is basisidx that have the following form:
It thus contains the number of primitives in each basisfunction, and what start index it have for loop inside the integral code.
The second array is basisint, that have the following forms:
The first one is for regular integrals and the second one is for derivatives. Both contains all the angular momentum quantum numbers, and the derivative also contains the atom index (used in derivative of VNe).
The last array is basisfloat and have the following forms:
basisfloat contains the normalization constants, Gaussian exponent and prefacor and the coordinates of the atoms. The second one is again for the derivatives, it contains normalization constants of the differentiated primitives.
Inputfile obejct¶
The inputfile obejct is a numpy array containing the following informations:
Settings obejct¶
The settings are parsed around in the code as a dictionary.
Results object¶
The results are parsed around in the code as a dictionary. It contains the results from different calculatations that are either used in other calculations or given as an output.


Sold old ten are quit lose deal his sent. You correct how sex several far distant believe journey parties. We shyness enquire uncivil affixed it carried to.
Sold old ten are quit lose deal his sent. You correct how sex several far distant believe journey parties. We shyness enquire uncivil affixed it carried to.
Falling in love was the easy part; planning a wedding - yikes!
21st November 2016
St Pancras Grand
Upper Concourse
Euston Road
North London
N1C 4QL


This is a slide deck from a session that I have done on Guided Code Katas in the past. Many of the resources are out of date though, so see the slide deck Software Craftsmanship and Agile Code Games for links.
Guides you step by step through a Kata for the FizzBuzz problem. Using C# and NUnit, discover how to take small steps while doing test driven development (TDD). Also see how far you can factor a solution to this problem and expand on it!
Guides you step by step through an adaptation of the Bowling Game Kata from Uncle Bob Martin in C# and NUnit.
My name is Mike Clement. I'm a husband, father of four, a Latter-day Saint and currently a Senior Software Craftsman at Pluralsight. I've worked at Ancestry.com, Microsoft, Caselle and a few other small companies.
I am one of the founding members of the Utah Software Craftsmanship group. I enjoy presenting at and attending conferences. I blog at Software on the Side. Opinions expressed here are my own and do not necessarily reflect those of my employer although I do hope that they coincide on occasion :)


Home
Projects
My 'How'
About me
I can help you design smooth
user experiences
See how
→
I'm a well-rounded
UX Designer
who can code
More about me
→
Here to check out
my
projects?
Take a look
→


More games
English
Français*
Deutsch
Italiano*
Español
日本語*
中文
Minidex
Consider a small donation if you find this app useful!
Donate
Not now
Now loading...
Collection
Competitive
Forms
Location
Evolution line
More information
Abilities
Damage taken


|
My Project
|
This file contains various command types and text descriptions. More...
Go to the source code of this file.
Macros | |
| #define | CMD_READ_VALUE "read" |
| #define | CMD_READ_DESC "read async" |
| #define | CMD_WRITE_VALUE "write" |
| #define | CMD_WRITE_DESC "write async" |
| #define | CMD_SUB_VALUE "sub" |
| #define | CMD_SUB_DESC "subscription" |
| #define | CMD_START_SERVER_VALUE "start_server" |
| #define | CMD_START_SERVER_DESC "start server" |
| #define | CMD_START_CLIENT_VALUE "start_client" |
| #define | CMD_START_CLIENT_DESC "start client and connect to server" |
| #define | CMD_STOP_SERVER_VALUE "stop_server" |
| #define | CMD_STOP_SERVER_DESC "stop server" |
| #define | CMD_STOP_CLIENT_VALUE "stop_client" |
| #define | CMD_STOP_CLIENT_DESC "stop client and disconnect" |
| #define | CMD_GET_ENDPOINTS_VALUE "endpoint_discovery" |
| #define | CMD_GET_ENDPOINTS_DESC "get end points from server" |
| #define | CMD_BROWSE_VALUE "browse" |
| #define | CMD_BROWSE_DESC "browse nodes from server" |
| #define | CMD_METHOD_VALUE "method" |
| #define | CMD_METHOD_DESC "call method nodes from server" |
Enumerations | |
| enum | EdgeCommand { CMD_READ = 0, CMD_WRITE = 1, CMD_SUB = 2, CMD_START_SERVER = 3, CMD_START_CLIENT = 4, CMD_STOP_SERVER = 5, CMD_STOP_CLIENT = 6, CMD_GET_ENDPOINTS = 7, CMD_BROWSE = 8, CMD_BROWSENEXT = 9, CMD_BROWSE_VIEW = 10, CMD_METHOD = 11 } |
This file contains various command types and text descriptions.
| #define CMD_BROWSE_DESC "browse nodes from server" |
Browse - Command description.
| #define CMD_BROWSE_VALUE "browse" |
Browse - String value.
| #define CMD_GET_ENDPOINTS_DESC "get end points from server" |
Get endpoints - Command description.
| #define CMD_GET_ENDPOINTS_VALUE "endpoint_discovery" |
Get endpoints - String value.
| #define CMD_METHOD_DESC "call method nodes from server" |
Method - Command description.
| #define CMD_METHOD_VALUE "method" |
Method - String value.
| #define CMD_READ_DESC "read async" |
Read - Command description.
| #define CMD_READ_VALUE "read" |
Read - String value.
| #define CMD_START_CLIENT_DESC "start client and connect to server" |
Start client - Command description.
| #define CMD_START_CLIENT_VALUE "start_client" |
Start client - String value.
| #define CMD_START_SERVER_DESC "start server" |
Start server - Command value.
| #define CMD_START_SERVER_VALUE "start_server" |
Start server - String value.
| #define CMD_STOP_CLIENT_DESC "stop client and disconnect" |
Stop client - Command description.
| #define CMD_STOP_CLIENT_VALUE "stop_client" |
Stop client - String value.
| #define CMD_STOP_SERVER_DESC "stop server" |
Stop server - Command description.
| #define CMD_STOP_SERVER_VALUE "stop_server" |
Stop server - String value.
| #define CMD_SUB_DESC "subscription" |
Subscription - Command description.
| #define CMD_SUB_VALUE "sub" |
Subscription - String value.
| #define CMD_WRITE_DESC "write async" |
Write - Command description.
| #define CMD_WRITE_VALUE "write" |
Write - String value.
| enum EdgeCommand |
Declares the commands(ie., services) supported by OPC UA wrapper.


Specific and class specific multiple correspondence analysis on survey-like data. Soc.ca is optimized to the needs of the social scientist and presents easily interpretable results in near publication ready quality.
| Version: | 0.7.3 |
| Depends: | R (≥ 2.15.0), ggplot2 |
| Imports: | gridExtra, ellipse, stats, utils, shiny, reshape2, ggrepel |
| Published: | 2016-02-09 |
| Author: | Anton Grau Larsen, with contributions from Christoph Ellersgaard and Stefan Andrade |
| Maintainer: | Anton Grau Larsen <agl.dbp at cbs.dk> |
| License: | GPL-3 |
| URL: | https://github.com/Rsoc/soc.ca |
| NeedsCompilation: | no |
| In views: | Psychometrics |
| CRAN checks: | soc.ca results |
| Reference manual: | soc.ca.pdf |
| Package source: | soc.ca_0.7.3.tar.gz |
| Windows binaries: | r-devel: soc.ca_0.7.3.zip, r-release: soc.ca_0.7.3.zip, r-oldrel: soc.ca_0.7.3.zip |
| OS X binaries: | r-release: soc.ca_0.7.3.tgz, r-oldrel: soc.ca_0.7.3.tgz |
| Old sources: | soc.ca archive |
Please use the canonical form https://CRAN.R-project.org/package=soc.ca to link to this page.


UX Aspects components can be used in Angular projects (Angular 15 and 16 are currently supported). The stylesheet can also be used in non-Angular projects to style basic controls.
Instructions on this page refer to the following software:
npm
command, which
is used to install application dependencies.
npm install --save @ux-aspects/ux-aspects
UX Aspects has a number of peer dependencies which should be met to ensure proper functionality across all components. You can select the version of each peer dependency that suits your application, provided it matches the peer version criteria.
Add the Bootstrap and UX Aspects stylesheets to the application. If using Angular CLI, add these via the
angular.json
file; otherwise, they can be imported into the master stylesheet. Note that the
order of import is significant.
Import the required component module(s) into the module that will be using them. The Usage dropdown in the documentation lists the module to import, where appropriate.
UX Aspects is an open source project, which means that everyone is welcome to participate in making improvements!
See CONTRIBUTING.md on GitHub for information on building, testing, and submitting pull requests for UX Aspects.
To get help with anything related to UX Aspects, please raise an issue on GitHub.


| Illness |
First Aid* |
|
Heat stroke
|
- HEAT STROKE IS A MEDICAL EMERGENCY. Call 911 While waiting for help:
- Place worker in shady, cool area
- Loosen clothing, remove outer clothing
- Fan air on worker; cool packs in armpits
- Wet worker with cool water; apply ice packs, cool compresses, or ice if available
- Provide fluids (preferably water) as soon as possible
- Stay with worker until help arrives
|
|
Heat exhaustion
|
- Have worker sit or lie down in a cool, shady area
- Give worker plenty of water or other cool beverages to drink
- Cool worker with cold compresses/ice packs
- Take to clinic or emergency room for medical evaluation and treatment if signs or symptoms worsen or do not improve within 60 minutes
- Do not return to work that day
|
|
Heat cramps
|
- Have worker rest in shady, cool area
- Have worker drink water or other cool beverages
- Wait a few hours before allowing worker to return to heavy work
- Seek medical attention if cramps don’t go away
|
|
| Heat rash |
- Try to work in a cooler, less humid environment when possible
- Keep the affected area dry
|
|
|
* Remember, if you are not a medical professional, use this information as a guide only to help protect workers in need.
|


@(page: model.Page, isAutoDeletion: Boolean)(implicit request: RequestHeader, context: model.ApplicationContext)
@if(isAutoDeletion) {
Your account has been successfully deleted.
Momentarily you will be signed out and redirected to the main Guardian home page.
} else {
Your account deletion request has been successfully submitted.
Our User Help agents are processing your request and will send you a confirmation email as soon as they have fully deleted your account.
Meanwhile you may continue to use your account. If you require further clarification please email our
Userhelp who will be happy to help.
}


--- layout: page title: About Me description: This is what I do. background: '/img/bg-about.jpg' ---
I'm a student at New York University Abu Dhabi, studying Interactive Media and Computer Science. I'm interested in Data Science, Journalism and anything in between.


Your device is misconfigured.
Unable to validate certificate. Make sure the device has a valid private.key and public.cert in the root directory.


|
Copley Motion Library
|
Configuration structure used to set up the Gain Scheduling. More...
Public Member Functions | |
| GainScheduling (void) | |
| Default constructor. More... | |
Public Attributes | |
| uint32 | gainSchedulingConfig |
| Gain Scheduling configuration. See documentation for details. | |
Configuration structure used to set up the Gain Scheduling.
These settings may be up/download from the amplifier using the functions Amp::SetGainScheduling and Amp::GetGainScheduling.
|
inline |
Default constructor.
Initializes all structure elements to zero.


--- layout: page title: Magic Item Price Calculator category: resource-tools excerpt: Need to figure out how much that item magic costs? Use this Calculator! Takes local variables into consideration to determine the price of a magical item. cta: Try out the calculator ---
gp
Optional Given the local and situational variables, figure out what kind of discount/markup you would expect.
Given the above, you might find an adjusted price of %.
Compare the player's CHA (Persuasion) against the shopkeeper's WIS (Insight). Consider giving the player advantage if they role played the interaction well.
%