Apache Beam is a rapidly-maturing software project with a strong commitment to testing. Consequently, it has many testing-related needs. It requires precommit tests to ensure code going into the repository meets a certain quality bar and it requires ongoing postcommit tests to make sure that more subtle changes which escape precommit are nonetheless caught. This document outlines how to write tests, which tests are appropriate where, and when tests are run, with some additional information about the testing systems at the bottom.
If you’re writing tests, take a look at the testing matrix first, find what you want to test, then look into the “Scenarios” and “Types” sections below for more details on those testing types.
| Component to Test | Test Scenario | Tool to Use | Link to Example | Type | Runs In |
| DoFn | Correctness on one/few bundles | DoFnTester | BigQueryIOTest | Unit | Precommit, Postcommit |
| BoundedSource | Correctly Reads Input | SourceTestUtils.readFromSource | TextIOTest | Unit | Precommit, Postcommit |
| Correct Initial Splitting | SourceTestUtils.assertSourcesEqualReferenceSource | BigtableTest | Unit | Precommit, Postcommit | |
| Correct Dynamic Splitting | SourceTestUtils. assertSplitAtFractionExhaustive | TextIOTest | Unit | Precommit, Postcommit | |
| Transform | Correctness | @NeedsRunner Test | ParDoTest | @NeedsRunner | |
| Example Pipeline | Verify Behavior on Each Runner | E2E Test | WordCountIT | E2E | Postcommit (Except WordCountIT) |
| Source/Sink with external resource | External Resource Faked | Unit / @NeedsRunner Test | FakeBigtableService in BigtableTest | Unit / @NeedsRunner | Precommit / Postcommit |
| Real Interactions With External Resource | E2E Test | BigtableReadIT | E2E | Postcommit | |
| Runner | Correctness | E2E Test, @ValidatesRunner | WordCountIT, ParDoTest | E2E, @ValidatesRunner | Postcommit |
| Coders | Encoding/decoding elements | CoderProperties | NullableCoderTest | Unit | Precommit / Postcommit |
| Serialization/deserialization of Coder | CoderProperties | NullableCoderTest | Unit | Precommit / Postcommit | |
| Sizing of elements | CoderProperties | NullableCoderTest | Unit | Precommit / Postcommit | |
| Deterministic | CoderProperties | NullableCoderTest | Unit | Precommit / Postcommit | |
| Structural value equality | CoderProperties | NullableCoderTest | Unit | Precommit / Postcommit |
The Python SDK has postcommit tests by a Jenkins build; precommit testing and a full testing matrix will be coming soon.
With the tools at our disposal, we have a good set of utilities which we can use to verify Beam correctness. To ensure an ongoing high quality of code, we use precommit and postcommit testing.
For precommit testing, Beam uses Jenkins and a code coverage tool called Coveralls, hooked up to Github, to ensure that pull requests meet a certain quality bar. These precommits verify correctness via two of the below testing tools: unit tests (with coverage monitored by Coveralls) and E2E tests. We run the full slate of unit tests in precommit, ensuring correctness at a basic level, and then run the WordCount E2E test in both batch and streaming (coming soon!) against each supported SDK / runner combination as a smoke test, to verify that a basic level of functionality exists. We think that this hits the appropriate tradeoff between a desire for short (ideally <30m) precommit times and a desire to verify that pull requests going into Beam function in the way in which they are intended.
Precommit tests are kicked off when a user makes a Pull Request against the
apache/beam
repository and the Jenkins and Coveralls statuses are displayed at
the bottom of the pull request page. Clicking on “Details” will open the status
page in the selected tool; there, test status and output can be viewed.
Running in postcommit removes as stringent of a time constraint, which gives us the ability to do some more comprehensive testing. In postcommit we have a test suite running the ValidatesRunner tests against each supported runner, and another for running the full set of E2E tests against each runner. Currently-supported runners are Dataflow, Flink, Spark, and Gearpump, with others soon to follow. Work is ongoing to enable Flink, Spark, and Gearpump in the E2E framework, with full support targeted for end of August 2016. Postcommit tests run periodically, with timing defined in their Jenkins configurations.
Adding new postcommit E2E tests is generally as easy as adding a *IT.java file to the repository - Failsafe will notice it and run it - but if you want to do more interesting things, take a look at WordCountIT.java.
Postcommit test results can be found in Jenkins.
Unit tests are, in Beam as everywhere else, the first line of defense in ensuring software correctness. As all of the contributors to Beam understand the importance of testing, Beam has a robust set of unit tests, as well as testing coverage measurement tools, which protect the codebase from simple to moderate breakages. Beam Java unit tests are written in JUnit.
ValidatesRunner tests contain components of both component and end-to-end tests. They fulfill the typical purpose of a component test - they are meant to test a well-scoped piece of Beam functionality or the interactions between two such pieces and can be run in a component-test-type fashion against the DirectRunner. Additionally, they are built with the ability to run in an end-to-end fashion against a runner, allowing them to verify not only core Beam functionality, but runner functionality as well. They are more lightweight than a traditional end-to-end test and, because of their well-scoped nature, provide good signal as to what exactly is working or broken against a particular runner.
End-to-End tests are meant to verify at the very highest level that the Beam codebase is working as intended. Because they are implemented as a thin wrapper around existing pipelines, they can be used to prove that the core Beam functionality is available. They will be used to verify runner correctness, but they can also be used for IO connectors and other core functionality.
The Beam end-to-end testing framework is a framework designed in a runner-agnostic fashion to exercise the entire lifecycle of a Beam pipeline. We run a pipeline as a user would and allow it to run to completion in the same way, verifying after completion that it behaved how we expected. Using pipelines from the Beam examples, or custom-built pipelines, the framework will provide hooks during several pipeline lifecycle events, e.g., pipeline creation, pipeline success, and pipeline failure, to allow verification of pipeline state.
The E2E testing framework is currently built to hook into the Maven Failsafe Integration Test plugin, which means it is tightly integrated with the overall build process. Once it is determined how Python and other future languages will integrate into the overall build/test system (via Maven or otherwise) we will adjust this. The framework provides a wrapper around actual Beam pipelines, enabling those pipelines to be run in an environment which facilitates verification of pipeline results and details.
Verifiers include:
The E2E framework will support running on various different configurations of environments. We currently provide the ability to run against the DirectRunner, against a local Spark instance, a local Flink instance, and against the Google Cloud Dataflow service.
ValidatesRunner tests are tests built to use the Beam TestPipeline class, which enables test authors to write simple functionality verification. They are meant to use some of the built-in utilities of the SDK, namely PAssert, to verify that the simple pipelines they run end in the correct state.
TestPipeline
is JUnit rule designed to facilitate testing pipelines.
In combination with PAssert
, the two can be used for testing and
writing assertions over pipelines. However, in order for these assertions
to be effective, the constructed pipeline must be run by a pipeline
runner. If the pipeline is not run (i.e., executed) then the
constructed PAssert
statements will not be triggered, and will thus
be ineffective.
To prevent such cases, TestPipeline
has some protection mechanisms in place.
Abandoned node detection (performed automatically)
Abandoned nodes are PTransforms
, PAsserts
included, that were not
executed by the pipeline runner. Abandoned nodes are most likely to occur
due to the one of the following scenarios:
pipeline.run()
statement at the end of a test.PTransform
s after the pipeline has already run.Abandoned node detection is automatically enabled when a real pipeline
runner (i.e. not a CrashingRunner
) and/or a
@NeedsRunner
/ @ValidatesRunner
annotation are detected.
Consider the following test:
// Note the @Rule annotation here
@Rule
public final transient TestPipeline pipeline = TestPipeline.create();
@Test
@Category(NeedsRunner.class)
public void myPipelineTest() throws Exception {
final PCollection<String> pCollection =
pipeline
.apply("Create", Create.of(WORDS).withCoder(StringUtf8Coder.of()))
.apply(
"Map1",
MapElements.via(
new SimpleFunction<String, String>() {
@Override
public String apply(final String input) {
return WHATEVER;
}
}));
PAssert.that(pCollection).containsInAnyOrder(WHATEVER);
/* ERROR: pipeline.run() is missing, PAsserts are ineffective */
}
# Unsupported in Beam's Python SDK.
The PAssert
at the end of this test method will not be executed, since
pipeline
is never run, making this test ineffective. If this test method
is run using an actual pipeline runner, an exception will be thrown
indicating that there was no run()
invocation in the test.
Exceptions that are thrown prior to executing a pipeline, will fail
the test unless handled by an ExpectedException
rule.
Consider the following test:
// Note the @Rule annotation here
@Rule
public final transient TestPipeline pipeline = TestPipeline.create();
@Test
public void testReadingFailsTableDoesNotExist() throws Exception {
final String table = "TEST-TABLE";
BigtableIO.Read read =
BigtableIO.read()
.withBigtableOptions(BIGTABLE_OPTIONS)
.withTableId(table)
.withBigtableService(service);
// Exception will be thrown by read.validate() when read is applied.
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage(String.format("Table %s does not exist", table));
p.apply(read);
}
# Unsupported in Beam's Python SDK.
The application of the read
transform throws an exception, which is then
handled by the thrown
ExpectedException
rule.
In light of this exception, the fact this test has abandoned nodes
(the read
transform) does not play a role since the test fails before
the pipeline would have been executed (had there been a run()
statement).
Auto-add pipeline.run()
(disabled by default)
A TestPipeline
instance can be configured to auto-add a missing run()
statement by setting testPipeline.enableAutoRunIfMissing(true/false)
.
If this feature is enabled, no exception will be thrown in case of a
missing run()
statement, instead, one will be added automatically.
The surface of an API is the set of public classes that are exposed to the
outer world. In order to keep the API tight and avoid unnecessarily exposing
classes, Beam provides the ApiSurface
utility class.
Using the ApiSurface
class, we can assert the API surface against an
expected set of classes.
Consider the following snippet:
@Test
public void testMyApiSurface() throws Exception {
final Package thisPackage = getClass().getPackage();
final ClassLoader thisClassLoader = getClass().getClassLoader();
final ApiSurface apiSurface =
ApiSurface.ofPackage(thisPackage, thisClassLoader)
.pruningPattern("org[.]apache[.]beam[.].*Test.*")
.pruningPattern("org[.]apache[.]beam[.].*IT")
.pruningPattern("java[.]lang.*");
@SuppressWarnings("unchecked")
final Set<Matcher<Class<?>>> allowed =
ImmutableSet.of(
classesInPackage("org.apache.beam.x"),
classesInPackage("org.apache.beam.y"),
classesInPackage("org.apache.beam.z"),
Matchers.<Class<?>>equalTo(Other.class));
assertThat(apiSurface, containsOnlyClassesMatching(allowed));
}
# Unsupported in Beam's Python SDK.
This test will fail if the classes exposed by getClass().getPackage()
, except
classes which reside under "org[.]apache[.]beam[.].*Test.*"
,
"org[.]apache[.]beam[.].*IT"
or "java[.]lang.*"
, belong to neither
of the packages: org.apache.beam.x
, org.apache.beam.y
, org.apache.beam.z
,
nor equal to Other.class
.


A11y Modal
This page demonstrates how to make a modal window as accessible as possible to assistive technology users. Modal windows are especially problematic for screen reader users. Often times the user is able to “escape” the window and interact with other parts of the page when they should not be able to. This is partially due to the way screen reader software interacts with the browser.
To see this in action, you just need to . Once it’s open, you should not be able to interact with other links on the main page like going to the main GitHub page. The focus is said to be “trapped” inside the modal until the user explicitely decides to leave it.
On top of that, this implementation provides all the usual mandatory bits from a modal window: correct usage or ARIA landmarks, absolute freedom in regard to the styling, closing when pressing ESC
, closing when clicking the background overlay, closing when clicking the close button, a simple yet powerful DOM API, for half a kilobyte of JavaScript. Oh, and also it is fully tested using a headless browser to make sure it works as intended.
No more excuse now. Make your modal windows accessible.


set clskip number <spacing>
number
is the number of contour lines to skip when
labelling
spacing
is an optional argument that controls the minimum distance between labels on a contour line (default = 2.5)
For example, set clskip 2
would label every other
contour.


Example of Xhr2 file upload, with progress bar
Choose a file and wait a little until it is uploaded (on a fake server).
Progress:


fieldset
and
legend
element tests
Published:
September 5th, 2019
fieldset
with a
legend
Legend
Option 1
Option 2
Option 3
Option 4


Philosophy behind the course structure
I took some inspiration from R for Data Science when it comes to what order to introduce different concepts. Their idea is to start with plotting, without any introduction to the R programming language whatsoever, including no explanation of the data types that are used when plotting. This is meant to start with introducing the visual stuff that you can play around with and get immediate (and sometimes pretty) feedback. After having seen what you can do in terms of visualising your data, only then do they start to talk about how to import data and tidying it up in order to be able to visualise it, using the visualisation as a motivation for the more boring task of cleaning you data.
Topics
These are the topics covered in the course, and each heading represents a lecture. A rough outline of the content is listed for each topic. The content is listed in the order it appears in the course.
Course introduction
- Welcome and overview of learning outcomes
- What the course is not
- Learning objectives and practical assignments
Introduction to R
- What is R
- Short history of R
RStudio
- Introduction to RStudio
- Walkthrough of download and installation
- Install some prerequisite packages, but don't go into details
Data visualisation with ggplot2
- Basic graphics
- The structure of a ggplot
- Don't talk about tidy data just yet, just use tidy data like
mpg
, diamonds
and nycflights13
.
- Factors and ordered factors
How to get help
- Specific functions:
?
, ??
, help
, F1, help pane
- General problems: Google, Stackoverflow
- RStudio cheat sheets
Basics of R coding
- Operators
- Basic operators (
+
, -
, /
, %%
, etc)
- Comparators
- Calling functions
- Data types
- Atomic types
- integer
- double
- logical
- character
- (complex)
- factor
- Vectors
- Lists
- Data frames
- Live demonstrations and practice using learnr (?)
- Writing scripts
R packages
- What is an R package?
- What is the base package?
- R packages that I use (almost) daily
- here
- conflicted
- dplyr
- ggplot2
- purrr
- stringr
- readr
- Many of these packages are part of the tidyverse
Data manipulation using dplyr
- Examples using the built-in datasets
mpg
, diamonds
, nycflights13
- Filtering
- Summarising
- Joining datasets
- RStudio cheat sheets
Tidy data
- What are some best practices when it comes to data representation?
- Each column is a variable
- Each row is an observation
- tidyverse
- Examples of how untidy data can make life difficult
- Are there times when these practices are not applicable?
Importing data into R
- readr package
- readxl package
- Load the data from the first course
Loading data into R, manipulation and visualisation
Reproducibility in data science
- Why is reproducibility important?
- Reproducibility crisis
- Difference between reproducibility and repeatability
- Project structure
- RStudio projects
- Coding standards
- How to ask for help
- reprex package
- Rubber ducking
Advanced plotting: The grammar of graphics
- The grammar helps us make correct plots
- How does it help us make good plots?
Advanced plotting: Dos and don'ts
Practical assignment 1
- Make available in the morning, deadline at midnight
- Plotting of built-in datasets
- Tidy up a dirty dataset and import into R
- Reproduce a figure from a publication given the input data
Data transformations
mutate
, scale
, log
- Testing for normality
- Heteroskedasticity
- What is it?
- Why do we see it?
Code sharing: R Markdown
- What is ® markdown?
- Example of how to create a self-documenting analysis
Data sharing
- Becoming more and more of a requirement by journals
- Zenodo
- Figshare
- Repositories for larger datasets (e.g. SRA, ENA)
Large-scale data
- How large is large?
- Examples of large-scale data
- Generally, we don't want to work with large-scale data directly in R
- Identify what is needed
- Extract what is needed
- Example: RNA-Seq
Quality control and visualisation of large-scale data
- UPSC pipeline for Biological QA
- Plotting whole datasets
- PCA, MDS
- Heatmaps
- Venn diagrams
- Plotting subsets of large datasets
- How do we choose a subset
- Faceting in ggplot2
Statistical testing
- t-test
- ANOVA
- Linear regression
- More in-depth explanation of factors
Statistical testing of course data
- qPCR?
- Pairwise review of the outcome
- Are conclusions supported by the tests?
Advanced R: Functions
- Writing your own functions
- Get specification on inputs and outputs
Journal guidelines for authors
- What requirements do journals often have?
- How can we create figures in ggplot2 that conform to these guidelines?
- What do the guidelines tell us about data sharing? What about code sharing?
Vectorisation and functional programming
- Why are
for
loops often slow?
- Difference between
&
/&&
, and |
/||
- apply/lapply vs purrr
Practical assignment 2
- Make available in morning
- Large scale data: ITS data from Andreas
- Plotting large scale data
Short-answer knowledge test
Course evaluation


--- layout: post title: library to share 14th century royal cookbook date: '2008-09-22T18:09:07+01:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/51263192/library-to-share-14th-century-royal-cookbook ---
Library to share 14th-century royal cookbook online


1 // Copyright 2005, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 // 31 // The Google C++ Testing and Mocking Framework (Google Test) 32 // 33 // This header file defines the Message class. 34 // 35 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to 36 // leave some internal implementation details in this header file. 37 // They are clearly marked by comments like this: 38 // 39 // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 40 // 41 // Such code is NOT meant to be used by a user directly, and is subject 42 // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user 43 // program! 44 45 // GOOGLETEST_CM0001 DO NOT DELETE 46 47 #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 48 #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 49 50 #include <limits> 51 52 #include "gtest/internal/gtest-port.h" 53 54 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 55 /* class A needs to have dll-interface to be used by clients of class B */) 56 57 // Ensures that there is at least one operator<< in the global namespace. 58 // See Message& operator<<(...) below for why. 59 void operator<<(const testing::internal::Secret&, int); 60 61 namespace testing { 62 63 // The Message class works like an ostream repeater. 64 // 65 // Typical usage: 66 // 67 // 1.  Then you stream the Message object to an ostream. 70 // This causes the text in the Message to be streamed 71 // to the ostream. 72 // 73 // For example; 74 // 75 // testing::Message foo; 76 // foo << 1 << " != " << 2; 77 // std::cout << foo; 78 // 79 // will print "1 != 2". 80 // 81 // Message is not intended to be inherited from. In particular, its 82 // destructor is not virtual. 83 // 84 // Note that stringstream behaves differently in gcc and in MSVC. You 85 // can stream a NULL char pointer to it in the former, but not in the 86 // latter (it causes an access violation if you do). The Message 87 // class hides this difference by treating a NULL char pointer as 88 // "(null)". 89 class GTEST_API_ Message { 90 private: 91 // The type of basic IO manipulators (endl, ends, and flush) for 92 // narrow streams. 93 typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); 94 95 public: 96 // Constructs an empty Message. 97 Message(); 98 99 // Copy constructor. 100 Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT 101 *ss_ << msg.GetString(); 102 } 103 104 // Constructs a Message from a C-string. 105 explicit Message(const char* str) : ss_(new ::std::stringstream) { 106 *ss_ << str; 107 } 108 109 #if GTEST_OS_SYMBIAN 110 // Streams a value (either a pointer or not) to this object. 111 template <typename T> 112 inline Message& operator <<(const T& value) { 113 StreamHelper(typename internal::is_pointer<T>::type(), value); 114 return *this; 115 } 116 #else 117 // Streams a non-pointer value to this object. 118 template <typename T> 119 inline Message& operator <<(const T& val) { 120 // Some libraries overload << for STL containers. These 121 // overloads are defined in the global namespace instead of ::std. 122 // 123 // C++'s symbol lookup rule (i.e. Koenig lookup) says that these 124 // overloads are visible in either the std namespace or the global 125 // namespace, but not other namespaces, including the testing 126 // namespace which Google Test's Message class is in. 127 // 128 // To allow STL containers (and other types that has a << operator 129 // defined in the global namespace) to be used in Google Test 130 // assertions, testing::Message must access the custom << operator 131 // from the global namespace. With this using declaration, 132 // overloads of << defined in the global namespace and those 133 // visible via Koenig lookup are both exposed in this function. 134 using ::operator <<; 135 *ss_ << val; 136 return *this; 137 } 138 139 // Streams a pointer value to this object. 140 // 141 // This function is an overload of the previous one. When you 142 // stream a pointer to a Message, this definition will be used as it 143 // is more specialized. (The C++ Standard, section 144 // [temp.func.order].) If you stream a non-pointer, then the 145 // previous definition will be used. 146 // 147 // The reason for this overload is that streaming a NULL pointer to 148 // ostream is undefined behavior. Depending on the compiler, you 149 // may get "0", "(nil)", "(null)", or an access violation. To 150 // ensure consistent result across compilers, we always treat NULL 151 // as "(null)". 152 template <typename T> 153 inline Message& operator <<(T* const& pointer) { // NOLINT 154 if (pointer == NULL) { 155 *ss_ << "(null)"; 156 } else { 157 *ss_ << pointer; 158 } 159 return *this; 160 } 161 #endif // GTEST_OS_SYMBIAN 162 163 // Since the basic IO manipulators are overloaded for both narrow 164 // and wide streams, we have to provide this specialized definition 165 // of operator <<, even though its body is the same as the 166 // templatized version above. Without this definition, streaming 167 // endl or other basic IO manipulators to Message will confuse the 168 // compiler. 169 Message& operator <<(BasicNarrowIoManip val) { 170 *ss_ << val; 171 return *this; 172 } 173 174 // Instead of 1/0, we want to see true/false for bool values. 175 Message& operator <<(bool b) { 176 return *this << (b ? "true" : "false"); 177 } 178 179 // These two overloads allow streaming a wide C string to a Message 180 // using the UTF-8 encoding. 181 Message& operator <<(const wchar_t* wide_c_str); 182 Message& operator <<(wchar_t* wide_c_str); 183 184 #if GTEST_HAS_STD_WSTRING 185 // Converts the given wide string to a narrow string using the UTF-8 186 // encoding, and streams the result to this Message object. 187 Message& operator <<(const ::std::wstring& wstr); 188 #endif // GTEST_HAS_STD_WSTRING 189 190 #if GTEST_HAS_GLOBAL_WSTRING 191 // Converts the given wide string to a narrow string using the UTF-8 192 // encoding, and streams the result to this Message object. 193 Message& operator <<(const ::wstring& wstr); 194 #endif // GTEST_HAS_GLOBAL_WSTRING 195 196 // Gets the text streamed to this object so far as an std::string. 197 // Each '\0' character in the buffer is replaced with "\\0". 198 // 199 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. 200 std::string GetString() const; 201 202 private: 203 #if GTEST_OS_SYMBIAN 204 // These are needed as the Nokia Symbian Compiler cannot decide between 205 // const T& and const T* in a function template. The Nokia compiler _can_ 206 // decide between class template specializations for T and T*, so a 207 // tr1::type_traits-like is_pointer works, and we can overload on that. 208 template <typename T> 209 inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) { 210 if (pointer == NULL) { 211 *ss_ << "(null)"; 212 } else { 213 *ss_ << pointer; 214 } 215 } 216 template <typename T> 217 inline void StreamHelper(internal::false_type /*is_pointer*/, 218 const T& value) { 219 // See the comments in Message& operator <<(const T&) above for why 220 // we need this using statement. 221 using ::operator <<; 222 *ss_ << value; 223 } 224 #endif // GTEST_OS_SYMBIAN 225 226 // We'll hold the text streamed to this object here. 227 const internal::scoped_ptr< ::std::stringstream> ss_; 228 229 // We declare (but don't implement) this to prevent the compiler 230 // from implementing the assignment operator. 231 void operator=(const Message&); 232 }; 233 234 // Streams a Message to an ostream. 235 inline std::ostream& operator <<(std::ostream& os, const Message& sb) { 236 return os << sb.GetString(); 237 } 238 239 namespace internal { 240 241 // Converts a streamable value to an std::string. A NULL pointer is 242 // converted to "(null)". When the input value is a ::string, 243 // ::std::string, ::wstring, or ::std::wstring object, each NUL 244 // character in it is replaced with "\\0". 245 template <typename T> 246 std::string StreamableToString(const T& streamable) { 247 return (Message() << streamable).GetString(); 248 } 249 250 } // namespace internal 251 } // namespace testing 252 253 GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 254 255 #endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_


Newspaper Broke Taboos, Defying Threats and Violence
By DOREEN CARVAJAL and SUZANNE DALEY
Charlie Hebdo was once firebombed, but it continued to amuse and horrify, taking pride in offending one and all.PARIS — In 2012, when Charlie Hebdo editors defied the government’s advice and published crude caricatures of the Prophet Muhammad naked and in sexual poses, the French authorities shut down embassies, cultural centers and schools in about 20 countries. “Is it really sensible or intelligent to pour oil on the fire?” asked Laurent Fabius, the foreign minister at the time.


--- layout: newsstory title: FOUR GOALS AND WE STILL CAN'T WIN match: Yeltz 4 Folkestone 4 ---
You'd have thought it would've been enough. Two goals apiece from Sutton and Payne took us into a 4-1 lead, but unbelieveably fellow strugglers Folkestone came back to earn what could be a vital point.
Some more squad changes - Scott Darroch has been released after never really looking up to playing at this level, and with Ralphy Crisp and Craig Mansell almost back to full fitness.
Tuesday's game at Burton has been called off because stupidly the league arranged a representative fixture in the same week as a full list of fixtures. Doh!
This means the next game is another important home league game - this time against Clevedon , who we've already beaten 4-1 this season. Come on.
Another interesting snippet of news - to quote Dave Johnson on the Mailing List :" Halesowen legends Paul and Lee Joinson have signed for Causeway Utd. (Halesowen's tenants) at the age of 40. Lee played yesterday at Shawbury and both could feature against top of the table Warley Rangers on Wednesday evening at The Grove."However Kev Crook says: "Sorry to have to inform you that all is not has it seems. Both Paul and Lee played for Causeway veterans on Saturday against a Tamworth side in some annual cup competition. I do not believe that this team play on a regular basis and also do not believe that the twins have any desire to make a come back although they where asked to sign for Causeway after finishing with Sandwell. I would doubt that they would be making an appearance in their 1st team on Wednesday as they probably won't be able to walk until Thursday."


Picture Search Helper
Setting
Key Words
Search on Abduzeedo
Search on Art Station
Search on Behance
Search on Creative Commons
Search on Designspiration
Search on Design*Sponge
Search on Deviant Art
Search on Dribble
Search on Inspirationde
Search on Juxtapoz
Search on Notefolio
Search on Pexel
Search on Pinterest
Search on PixaBay
Search on Pixiv
Search on Unsplash


This variable provides the data for the "List File of Type" part of the Windows File Open and File Save As dialog boxes.
The value is a set of pairs of text lines. The first line of the pair is a description and the second line of the pair is a list of file filters.
For example to have filters for text files (*.txt) and C file (*.c and *.h):
(setq UI-filter-file-list "Text files\n*.txt\nC files\n*.c;*.h")Default value:
"C/C++ Source code\n" "*.c;*.h;*.cpp;*.rc;*.def\n" "MLisp source code\n" "*.ml;*.mlp,*.key\n" "Text Files\n" "*.txt\n" "Ini Files\n" "*.ini;*.sys;*.bat;*.btm\n" "All Files (*.*)\n" "*.*\n"See also:
This variable provides the file name for the Windows File Open dialog boxes.
See also:
This variable provides the setting of the Read only check box for the Windows File Open dialog boxes.
Default value: 0
See also:
This variable provides the file name for the Windows File Save As dialog box.
Default value: ""
See also:
This variable provides the initial "Find what" string for the Windows Find and Find and Replace dialog boxes.
When the dialog box is close UI-search-string will hold the last value of the "Find what" field.
Default value: ""
See also:
This variable provides the initial "Replace with" string for the Windows Find and Replace dialog box.
When the dialog box is close UI-replace-string will hold the last value of the "Replace with" field.
Default value:
See also:
Graphic rendition for any text coloured as 1 by apply-colour-to-region.
Graphic rendition for any text coloured as 2 by apply-colour-to-region.
Graphic rendition for any text coloured as 3 by apply-colour-to-region.
Graphic rendition for any text coloured as 4 by apply-colour-to-region.
Graphic rendition for any text coloured as 5 by apply-colour-to-region.
Graphic rendition for any text coloured as 6 by apply-colour-to-region.
Graphic rendition for any text coloured as 7 by apply-colour-to-region.
Graphic rendition for any text coloured as 8 by apply-colour-to-region.
This variable is intended for use of the shipped Emacs MLisp code only.
The procedure named in this variable is executed:
- after restoring the Emacs environment, or executing the emacs_profile.ml
- before calling the procedure in the enter-emacs-hook.
The user-interface-hook is intended to run a procedure that customises the Emacs user interface based on present environment. This cannot be done and saved in environment file and it is a snapshot taken in the past.
Controls the deletion of checkpoint files. If non-zero, Emacs will unlink the corresponding checkpoint file after the master copy of the file is written. This avoids .CKP files from building up, but it does compromise safety a little.