Hemi includes framework-level unit testing capabilities with the Test Module and on-demand performance testing with JavaScript Function Monitor. The included Test Suite Template and Fragment make it very easy to write in-page unit tests for existing applications, or to implement Hemi while following TDD best practices.
The goal of this Get Started with Hemi article will be to create the same objects as are created in the Get Started with Hemi and DWAC, except to do the testing up front. If you read and worked through the Get Started with Hemi and DWAC, you can reference your project files from these tests, assuming both this page and the DWAC tool are on the same domain. The objects we want to create are:
First, let's get familiar with the test tool, Test Suite, and the Test API. Test Suite may load tests from external .js files, or from custom text. The syntax of a test is straightforward: A JavaScript function that starts with Test, which receives one parameter, TestResult, and which may return true or false. The JavaScript is loaded through the Test Module into the Module service. The result is that the once global Javascript function becomes an intimate part of a unique Test Module instance. The test has its own context, lifecycle, and works with other tests defined in the same text block or script file to form a Test Suite.
Consider the following example test:
// A test created for 'something'. function TestSomething(oTestResult){ // Log results are visible from the console this.log("Example test"); this.Assert(true); }
Click the 'Run Current Test' button to try it out. Tip: You can type in your own test function into the text field and click the 'Reset Current Test' button.
Apart from writing a javascript function that begins with Test, one other important feature to keep in mind is synchronicity. Every test is assumed to by synchronous, and, therefore, the return value is assumed to be true. By returning false, the Test indicates it is not finished processing. To finish processing, the Test must at some point invoke the EndTest method. Behind the scenes, the test service uses the Task Service to keep track of the test states.
The following example test demonstrates asynchronous tests.
function TestStartAsyncSomething(oTestResult){ // Do something, waiting for a reult return false; } function TestFinishAsyncSomething(oTestResult){ // Use this test to finish the previous test. EndTestStartAsyncSomething(true); }
Notice there are two tests. Click 'Run' next to the first test. Notice that the test does not complete. Click 'Run' next to the second test and notice the first test finishes.
The first set of tests should be to try to load each of the non-existent objects: two templates, one fragment, and one component. The templates and components are easy because they are first-class Application Component features. In fact, the hemi.app library includes wrappers to make it pretty easy to load, the Feature Verification Tests (FVTs) include examples (template tests : test.app.comp.js), and the Runtime Container fragment used for DWAC projects provides ever more example material.
This test will assume that at some point a file named ExampleTemplateContainer.xml will exist in the same directory as the page running the test..
There are several ways to load templates. An XML request, a direct node reference, via the hemi.app.createApplicationComponent wrapper, or building up the necessary hemi.object.xhtml and hemi.app.comp objects, or using the template attribute within an Application Space. The easiest way to load a template is with the attribute, such as:
 This is also a hard test to reuse because it is so dependent on a clean environment, and assumes the test host already made an attempt to load the test template.
// Given some HTML on the page //
 function TestTemplateWithSpaces(oResult){ var oSpace = Hemi.app.space.service.getPrimarySpace(); var oObject = oSpace.getSpaceObjectByName("ExampleTemplateContainer"); if(oObject && oObject.object) this.Assert(oObject.object.getContainer().innerHTML.match(/Example Template Container/),"Example text not found"); }
Although it is more work on the testing side, adding a few extra lines makes it more reusable.
function TestFragment(){ var oDiv = document.createElement("div"); var oX = Hemi.object.xhtml.newInstance(oDiv, 1); var oA = Hemi.app.comp.newInstance(0,0,oX.getObjectId(),0,0,1); oA.setTemplateIsSpace(1); oA.setAsync(false); var oXml = Hemi.xml.getXml("Examples/ExampleTemplateContainer.xml"); this.Assert(oXml != null, "Template not found"); oA.loadTemplateFromNode(oXml.documentElement); this.Assert(oA.getContainer().innerHTML.match(/Example Template Container/i),"Example text not found"); }
Testing can be a bit tricky when using loadTemplate because the method only serves as an input and not an output, primarily to handle asynchronous requests. Therefore, the test would need to be asynchronous and listen for the ontemplateload message. Because the template doesn't exist, we also need an extra check to determine it failed to load. A setTimeout is used for two seconds. If the template loads within that two seconds, a property is set on the test. At the end of two seconds, the test is ended with the result being the state of that property. Whenever the template loads, the property will be true and the test will pass.
this.Initialize = function(){ Hemi.message.service.subscribe("ontemplateload",HandleTemplateLoad); }; this.Unload = function(){ Hemi.message.service.unsubscribe("ontemplateload",HandleTemplateLoad); var oComp = Hemi.app.space.service.getPrimarySpace().getSpaceObjectByName("Test Example Template"); if(oComp && oComp.object) oComp.object.destroy(); }; function CheckTemplateLoad(){ EndTestLoadExampleTemplateContainer((Module.getProperties().template_loaded ? true : false)); } function HandleTemplateLoad(sMessage, vData){ if (vData.getContainerComponentId() == "Test Example Template") Module.getProperties().template_loaded = 1; } function TestLoadExampleTemplateContainer(oTestResult){ // Make an HTML element for the Template var oDiv = document.createElement("div"); oDiv.appendChild(document.createTextNode("Test")); document.body.appendChild(oDiv); this.getObjects().div = oDiv; // Give the component the RID: "Test Example Template" var oComp = Hemi.app.createApplicationComponent(0, oDiv, Hemi.app.space.service.getPrimarySpace(),"Test Example Template"); window.setTimeout(CheckTemplateLoad,2000); oComp.loadTemplate("Examples/ExampleTemplateContainer.xml"); return false; }
Component tests are straight forward, provided the component file name follows the convention component.[name].xml.
function TestLoadComponent(){ var oComp = Hemi.app.createApplicationComponent("Examples/component.test.xml"); this.Assert(oComp, "Component was not created"); this.Assert((oComp.getReadyState() == 4), "Component readyState is unexpected."); }
Fragments are bits of XHTML and script that are reusable components within the object space of a template. Fragments are largely conceptual in nature in that they exist as a space definition, import-xml, and that, like Templates, they are pre-processed by Application Components for special tokens and embedded-script statements. Application Space configuration provides the abstraction and primary processing mechanism for Fragments and Templates. In fact, Fragments ande Templates look very similar, with three notable exceptions:
Much like testing Templates, there are several ways to test Fragments. The easiest way would be to define the fragment in an existing template, and then reuse the existing Template test. However, this does not make for maintainable tests. Ideally, the Fragment test would not be dependent on a Template. So, that is the unit test we will make.
function TestFragment(){ var oDiv = document.createElement("div"); var oX = Hemi.object.xhtml.newInstance(oDiv, 1); var oA = Hemi.app.comp.newInstance(0,0,oX.getObjectId(),0,0,1); oA.setTemplateIsSpace(1); oA.setAsync(false); var oTemplate = Hemi.xml.parseXmlDocument("<Template><import-xml src = \"Examples/ExampleFragment.xml\" /></Template>"); oA.loadTemplateFromNode(oTemplate.documentElement); this.Assert(oA.getContainer().innerHTML.match(/example fragment/i),"Fragment text not found"); }
[ Stephen W. Cote, 2010 - BSD ]


Soldiers rescue man, wife held by jihadists
by Agency ReportPhilippine soldiers on Monday rescued a British man and his wife from Islamic State-linked jihadists nearly two months after the couple were kidnapped from their beach resort in the nation’s south, authorities said.
Troops recovered the pair after a firefight with gunmen from the Abu Sayyaf group on the restive southern island of Jolo, which is a stronghold of the kidnap-for-ransom gang that has been behind some of the worst attacks in the Philippines.
“There was a brief exchange of fire, but they later abandoned the couple after being overwhelmed by pursuing government forces,” Lieutenant General Cirilito Sobejana told AFP.
Regional army spokesman Arvin Encinas said no ransom was paid.
British Foreign Secretary Dominic Raab confirmed the rescue of the couple, saying “both Alan and Wilma Hyrons are safe and well, and being looked after by the Philippine authorities.”
“We worked closely with the Government of the Philippines on Alan and Wilma’s case over the last two months,” he added in a statement.
Armed men abducted the couple on October 4 at their beach resort on the southern island of Mindanao, which makes up the southern third of the Philippines.
Muslim separatists have led a decades-long insurgency in the south of the Catholic-majority Philippines, which has led to the death of tens of thousands of people.
While the government has negotiated peace with the largest group, the Moro Islamic Liberation Front, hardline factions allied with the Islamic State group are not part of the accord.
IS claimed responsibility for a suicide bombing on a Sunday mass in January at a Catholic cathedral on Jolo which killed 21 in the country’s worst attack in years.
Authorities blamed the bombing on Abu Sayyaf, which in part funds its violence with ransom payments.
Dutch birdwatcher Ewold Horn, who was kidnapped in 2012 in the southern Philippines, was killed in May during a firefight between his Abu Sayyaf captors and the military.
(AFP)


Goal: $10,000
$5703
- Updated: August 13th
- €1 = $1.1765
- Submit a Donation
- Donation Analysis
{{ partial "meta.html" . }}
Haiku is an open-source operating system that specifically targets personal computing. Inspired by the BeOS, Haiku is fast, simple to use, easy to learn and yet very powerful.
The Haiku source is continually built and released for testing purposes nearly every day. You can download and install these latest snapshots to check out the latest features and bug-fixes.
Be aware that nightly images may be unstable. Additionally, some packages included with official releases need to be installed separately.
If you're OK with this, you can find further instructions at our Nightly image page.


What happens near me?
Police
Traffic
Roadworks
PSA
Infrastructure
email
Email
phone
Phone Number
Subscribe
mode_edit
call
reorder
Report to Police
account_circle
Full Name
Full Name
phone
Telephone
Telephone
File
mode_edit
Report Content


GIS In Action - 2015
Blair Deaver - GeoEngineersWhy use the Cloud?
__________ as a Service
Reasons Why
Use Case - Emergency Swipe Imagery Map
Pricing and Gov Cloud
How to Get Started
Questions
Technology development team at GeoEngineers Inc, a national leader in earth science consulting.
Geospatial | Visualization | Cloud | Products | Solutions
For all new Product and Solution deployments
AWS OpsWorks
Automate your Infrastructure
"Can I destroy my dev environment at midnight?" - Yes
"Can I rebuild my dev environment at 4 am?" - Yes
Map Tiling
Geoprocessing | Data Conversion
Backup | Recovery
Web Application Hosting
Database Support {PostGIS/PostgreSQL and SQL Server}
The customer needs a Web Map NOW
Site may experience heavy traffic due to diaster event.


[1] V. Bala and S. Kipnis. Process groups: a mechanism for the coordination of and communication among processes in the Venus collective communication library. Technical report, IBM T. J. Watson Research Center, October 1992. Preprint.
[2] V. Bala, S. Kipnis, L. Rudolph, and Marc Snir. Designing efficient, scalable, and portable collective communication libraries. Technical report, IBM T. J. Watson Research Center, October 1992. Preprint.
[3] Purushotham V. Bangalore, Nathan E. Doss, and Anthony Skjellum. MPI++: Issues and Features. In OON-SKI '94, page in press, 1994.
[4] A. Beguelin, J. Dongarra, A. Geist, R. Manchek, and V. Sunderam. Visualization and debugging in a heterogeneous environment. IEEE Computer, 26(6):88--95, June 1993.
[5] Luc Bomans and Rolf Hempel. The Argonne/GMD macros in FORTRAN for portable parallel programming and their implementation on the Intel iPSC/2. Parallel Computing, 15:119--132, 1990.
[6] Rajesh Bordawekar, Juan Miguel del Rosario, and Alok Choudhary. Design and evaluation of primitives for parallel I/O. In Proceedings of Supercomputing '93, pages 452--461, 1993.
[7] R. Butler and E. Lusk. User's guide to the p4 programming system. Technical Report TM-ANL--92/17, Argonne National Laboratory, 1992.
[8] Ralph Butler and Ewing Lusk. Monitors, messages, and clusters: The p4 parallel programming system. Parallel Computing, 20(4):547--564, April 1994. Also Argonne National Laboratory Mathematics and Computer Science Division preprint P362-0493.
[9] Robin Calkin, Rolf Hempel, Hans-Christian Hoppe, and Peter Wypior. Portable programming with the PARMACS message-passing library. Parallel Computing, 20(4):615--632, April 1994.
[10] S. Chittor and R. J. Enbody. Performance evaluation of mesh-connected wormhole-routed networks for interprocessor communication in multicomputers. In Proceedings of the 1990 Supercomputing Conference, pages 647--656, 1990.
[11] S. Chittor and R. J. Enbody. Predicting the effect of mapping on the communication performance of large multicomputers. In Proceedings of the 1991 International Conference on Parallel Processing, vol. II (Software), pages II--1 -- II--4, 1991.
[12] Parasoft Corporation. Express version 1.0: A communication environment for parallel computers, 1988.
[13] Juan Miguel del Rosario, Rajesh Bordawekar, and Alok Choudhary. Improved parallel I/O via a two-phase run-time access strategy. In IPPS '93 Workshop on Input/Output in Parallel Computer Systems, pages 56--70, 1993. Also published in Computer Architecture News 21(5), December 1993, pages 31--38.
[14] J. Dongarra, A. Geist, R. Manchek, and V. Sunderam. Integrated PVM framework supports heterogeneous network computing. Computers in Physics, 7(2):166--75, April 1993.
[15] J. J. Dongarra, R. Hempel, A. J. G. Hey, and D. W. Walker. A proposal for a user-level, message passing interface in a distributed memory environment. Technical Report TM-12231, Oak Ridge National Laboratory, February 1993.
[16] Edinburgh Parallel Computing Centre, University of Edinburgh. CHIMP Concepts, June 1991.
[17] Edinburgh Parallel Computing Centre, University of Edinburgh. CHIMP Version 1.0 Interface, May 1992.
[18] Margaret A. Ellis and Bjarne Stroustrup. The Annotated C++ Reference Manual. Addison Wesley, 1990.
[19] D. Feitelson. Communicators: Object-based multiparty interactions for parallel programming. Technical Report 91-12, Dept. Computer Science, The Hebrew University of Jerusalem, November 1991.
[20] C++ Forum. Working paper for draft proposed international standard for information systems --- programming language C++. Technical report, American National Standards Institute, 1995.
[21] Message Passing Interface Forum. MPI: A Message-Passing Interface standard. The International Journal of Supercomputer Applications and High Performance Computing, 8, 1994.
[22] Message Passing Interface Forum. MPI: A Message-Passing Interface standard (version 1.1). Technical report, 1995. http://www.mpi-forum.org.
[23] Al Geist, Adam Beguelin, Jack Dongarra, Weicheng Jiang, Bob Manchek, and Vaidy Sunderam. PVM: Parallel Virtual Machine---A User's Guide and Tutorial for Network Parallel Computing. MIT Press, 1994.
[24] G. A. Geist, M. T. Heath, B. W. Peyton, and P. H. Worley. PICL: A portable instrumented communications library, C reference manual. Technical Report TM-11130, Oak Ridge National Laboratory, Oak Ridge, TN, July 1990.
[25] William D. Gropp and Barry Smith. Chameleon parallel programming tools users manual. Technical Report ANL-93/23, Argonne National Laboratory, March 1993.
[26] Michael Hennecke. A Fortran 90 interface to MPI version 1.1. Technical Report Internal Report 63/96, Rechenzentrum, Universität Karlsruhe, D-76128 Karlsruhe, Germany, June 1996. Available via world wide web from http://www.uni-karlsruhe.de/\ Michael.Hennecke/Publications/#MPI_F90.
[27] Institute of Electrical and Electronics Engineers, New York. IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Standard 754-1985, 1985.
[28] International Organization for Standardization, Geneva. Information processing --- 8-bit single-byte coded graphic character sets --- Part 1: Latin alphabet No. 1, 1987.
[29] International Organization for Standardization, Geneva. Information technology --- Portable Operating System Interface (POSIX) --- Part 1: System Application Program Interface (API) [C Language], December 1996.
[30] Charles H. Koelbel, David B. Loveman, Robert S. Schreiber, Guy L. Steele Jr., and Mary E. Zosel. The High Performance Fortran Handbook. MIT Press, 1993.
[31] David Kotz. Disk-directed I/O for MIMD multiprocessors. In Proceedings of the 1994 Symposium on Operating Systems Design and Implementation, pages 61--74, November 1994. Updated as Dartmouth TR PCS-TR94-226 on November 8, 1994.
[32] O. Krämer and H. Mühlenbein. Mapping strategies in message-based multiprocessor systems. Parallel Computing, 9:213--225, 1989.
[33] S. J. Lefflet, R. S. Fabry, W. N. Joy, P. Lapsley, S. Miller, and C. Torek. An advanced 4.4BSD interprocess communication tutorial, Unix programmer's supplementary documents (PSD) 21. Technical report, Computer Systems Research Group, Depertment of Electrical Engineering and Computer Science, University of California, Berkeley, 1993. Also available at http://www.netbsd.org/Documentation/lite2/psd/.
[34] nCUBE Corporation. nCUBE 2 Programmers Guide, r2.0, December 1990.
[35] Bill Nitzberg. Performance of the iPSC/860 Concurrent File System. Technical Report RND-92-020, NAS Systems Division, NASA Ames, December 1992.
[36] William J. Nitzberg. Collective Parallel I/O. PhD thesis, Department of Computer and Information Science, University of Oregon, December 1995.
[37] 4.4BSD Programmer's Supplementary Documents (PSD). O'Reilly and Associates, 1994.
[38] Paul Pierce. The NX/2 operating system. In Proceedings of the Third Conference on Hypercube Concurrent Computers and Applications, pages 384--390. ACM Press, 1988.
[39] K. E. Seamons, Y. Chen, P. Jones, J. Jozwiak, and M. Winslett. Server-directed collective I/O in Panda. In Proceedings of Supercomputing '95, December 1995.
[40] A. Skjellum and A. Leung. Zipcode: a portable multicomputer communication library atop the reactive kernel. In D. W. Walker and Q. F. Stout, editors, Proceedings of the Fifth Distributed Memory Concurrent Computing Conference, pages 767--776. IEEE Press, 1990.
[41] A. Skjellum, S. Smith, C. Still, A. Leung, and M. Morari. The Zipcode message passing system. Technical report, Lawrence Livermore National Laboratory, September 1992.
[42] Anthony Skjellum, Nathan E. Doss, and Purushotham V. Bangalore. Writing Libraries in MPI. In Anthony Skjellum and Donna S. Reese, editors, Proceedings of the Scalable Parallel Libraries Conference, pages 166--173. IEEE Computer Society Press, October 1993.
[43] Anthony Skjellum, Nathan E. Doss, and Kishore Viswanathan. Inter-communicator extensions to MPI in the MPIX (MPI eXtension) Library. Technical Report MSU-940722, Mississippi State University --- Dept. of Computer Science, April 1994. http://www.erc.msstate.edu/mpi/mpix.html.
[44] Anthony Skjellum, Ziyang Lu, Purushotham V. Bangalore, and Nathan E. Doss. Explicit parallel programming in C++ based on the message-passing interface (MPI). In Gregory V. Wilson, editor, Parallel Programming Using C++, Engineering Computation Series. MIT Press, July 1996. ISBN 0-262-73118-5.
[45] Anthony Skjellum, Steven G. Smith, Nathan E. Doss, Alvin P. Leung, and Manfred Morari. The Design and Evolution of Zipcode. Parallel Computing, 20(4):565--596, April 1994.
[46] Rajeev Thakur and Alok Choudhary. An Extended Two-Phase Method for Accessing Sections of Out-of-Core Arrays. Scientific Programming, 5(4):301--317, Winter 1996.
[47] The Unicode Standard, Version 2.0. Addison-Wesley, 1996. ISBN 0-201-48345-9.
[48] D. Walker. Standards for message passing in a distributed memory environment. Technical Report TM-12147, Oak Ridge National Laboratory, August 1992.


I am a geophysicist with a master degree in science from ETH Zurich, who would like to work as a data scientist. Please read more about me in this page. I have working experience in Syria and as well in Switzerland. After graduation from ETH I did many internships in different fields. Last of them was as a consultant at Oliver Wyman...