text:
B2C Website
B2B Website
Winter Love in Austria 22/23
Home Payment Conditions
General contractual and payment conditions for the Österreich Werbung Association
(A-1030 Wien, Vordere Zollamtsstraße 13)
(As of 01.02.2021)
The Österreich Werbung Association (hereinafter referred to as "ÖW") principally awards contracts only on the basis of the following terms and conditions.
The contractual partners hereby expressly acknowledge that they have agreed to these legally binding terms and conditions, so that these shall constitute the subject matter of the contract. These order and payment conditions are binding for all current and future business transactions, even if they are not expressly referred to.
Any amendments or modifications to the following terms and conditions must be made in writing and by mutual agreement, whereby, without prejudice to the foregoing, the unamended terms and conditions shall remain an integral part of the contract.
2. Award of contracts
All contracts and agreements shall only be binding for ÖW, if they have been effected in writing and duly signed by both the contractor and ÖW and shall only be binding on ÖW to the extent set forth in the order confirmation.
Offers directed at ÖW shall be free of cost, unless otherwise agreed upon in writing. Unless otherwise specified by ÖW, offers are binding for at least two months.
General Terms and Conditions of the Contractor are hereby excluded. Agreements to the contrary shall require the prior written consent of ÖW
3. Duty to warn
The Contractor shall be obliged to notify the Principal immediately and in writing of any circumstances that have come to its attention, which may jeopardise the fulfilment of the agreed contract, including the details and any proposed measures to be taken in relation thereto.
4. Execution of contract
Provided that the Contractor has been contracted to provide work delivery or work performance, ÖW reserves the right to request amendments or modifications to the contract at any time before acceptance.
The Contractor shall act in the best interest of ÖW and shall, at its own initiative, propose amendments to ÖW, which it deems necessary or appropriate for a successful performance of the contract. The implementation of such amendments shall be subject to the prior written consent of ÖW.
Insofar as an amendment gives rise to an increase or decrease in costs or may lead to a noncompliance with the scheduled delivery time, the Contractor shall be obliged to inform ÖW hereto, in writing, at the time of submitting its amendment proposals, or without delay following the receipt of ÖW's amendment request and to submit an appropriate supplementary offer.
The amendments shall be made on the basis of a separate written agreement, which shall specify the compensation for additional costs or take into account reduced costs, as well as, if need be, any amendments to the time schedule. The additional compensation shall be determined on the basis of the pricing of the contractual performance and the specific costs related to the requested additional performance.
5. Subcontractors
The transfer of the entire contract or parts thereof to third parties, as well as the hiring of subcontractors and the assignment of individual rights from an order / contract shall only be permissible with the prior written consent of ÖW. In reaching its decision, ÖW shall particularly take into account the experience, suitability in terms of procurement law, and the financial standing of the subcontractor, as well as the interests of the contractor.
6. Completion
6.1 Dates and partial services
Unless otherwise agreed upon for the respective contract, the Contractor shall make its deliveries to the agreed delivery address or to the address specified in the order confirmation "DDP" (pursuant to INCOTERMS 2000).
ÖW shall notify the Contractor, without delay, of any defects in delivery, as soon as they become apparent in the ordinary course of business. The duty to give notice of defects pursuant to Art. 377 UGB is thus hereby expressly waived.
Unless otherwise expressly agreed upon in writing, partial performances and/or partial deliveries shall not be permitted.
If the contractor enters into default, ÖW is entitled to charge a price reduction of 0.5% per day of the total order value excluding VAT, but up to a maximum of 10% of the total order value excluding VAT.
6.2 Force Majeure
Force majeure exists if ÖW or the Contractor is prevented from fulfilling his/her contractual obligations by an event that lies outside of his/her sphere of influence and could not be foreseen or - insofar as it was foreseeable - was unavoidable.
A case of force majeure is classified as such when it meets the above requirements. Force majeure includes in particular:
i. the outbreak of infectious disease, war, riot, sabotage or terrorism;
ii. Natural disasters such as lightning, fire, explosion, flood, and earthquake;
iii. official orders in connection with sub-items i. and ii .;
The contracting parties are released from fulfilling their contractual obligations in correspondence with the extent and duration of the force majeure event. If the mutual services are to be provided in connection with a fixed delivery date, both contracting parties are permanently released from the mutual obligations in the event of force majeure. Both contracting parties bear the costs incurred by themselves. Costs that the contractor incurred by way of third parties in connection with the order in question before the occurrence of this event will be borne by the contractor.
The contracting party affected by an event of force majeure must immediately and demonstrably notify the other contracting party of the occurrence of a force majeure event. The expected duration of this event and the extent to which the fulfillment of the contractual obligations is impaired must be disclosed as far as possible. The contracting party affected by the force majeure event must make all reasonable efforts to re-fulfill the contract as soon as possible, provided that the subject of the contract is not one with fixed delivery date(s), where time is of the essence.
In the event that a force majeure event interrupts the fulfillment of the contractual obligations for more than 6 weeks, both contracting parties are entitled to withdraw from the contract. Both contracting parties bear the costs incurred by them. Costs that the contractor incurred by way of third parties in connection with the order in question before the occurrence of this event will be borne by the contractor.
It is hereby made clear that no contracting party can assert claims for damages due to a contract termination or delay in the provision of services in the event of force majeure.
6.3 Acceptance and transfer of the required documents
In case the Contractor owes work performance or work delivery, a formal acceptance by ÖW shall be required. In case the inspection of the supplier's performance requires it being put into use or commissioning for testing purposes, acceptance shall only ensue after a successful completion of such tests.
Risks and title to the delivered item shall pass to ÖW upon acceptance.
7. Quality of execution and failure in performance
The contractor shall be obliged to supply the delivery and / or service to the extent contractually agreed on, by the agreed delivery date at the agreed price.
The Contractor shall deliver and / or supply the highest quality in accordance with the respective performance standard (e.g. state of the art), unless otherwise agreed upon in writing in individual cases.
In the case of improper performance (particularly with respect to the delivery date, quantity and / or quality), ÖW shall, without prejudice to claims for damages, be entitled to use the following options available, at its own discretion:
In case of non-compliance with the agreed delivery date and / or significant defects in quality and quantity, to rescind the contract without granting an extension;
to grant a reasonable extension for the rectification of defects, whereby, at the discretion of ÖW, the rectification shall either take the form of a replacement or repair;
to have the rectification of defects carried out by a third party and demand a reduction in price, whereby all costs relating thereto shall be borne by the Contractor and the latter shall not have any entitlement to selecting the company, which shall be carrying out the rectification of defects;
in the case of rescission of the contract, to award the contract to a third company, whereby additional costs shall be borne by the contractor.
8. Rescission of contract
In the case of a justified rescission of the contract on the part of ÖW (due to non-performance, delay or improper performance by the Contractor), the Contractor shall in any case be obliged to pay to ÖW, as minimum compensation and without prejudice to further claims for damages by ÖW, contractual penalty irrespective of fault amounting to 20% of the net contract value.
9. Extraordinary right of termination
ÖW shall be entitled to terminate the contract regarding an order or parts thereof, with immediate effect, if, based on serious grounds, ÖW can no longer be expected to continue with the contract. ÖW can particularly not be expected to continue with the contract, if
the Contractor fails to provide the agreed service or fails to provide it on time,
the Contractor fails to meet the agreed deadlines and there is a risk of delay regarding the timely provision of the service and/or delivery,
the contractor fails to rectify defects, after being requested to so by ÖW, within the reasonable period given,
the Contractor violates any other provision of these General Terms and Conditions and Payment, or of the Contract, or of official regulations,
the Contractor becomes insolvent, suspends payments or an application for the opening of insolvency proceedings against the assets of the Contractor is lodged or has been rejected for lack of sufficient assets.
there is an infringement of the provisions of the MedKF-TG and the Contractor fails to undertake necessary modifications, despite having been requested to do so by ÖW.
the Contractor and / or its subcontractors do not and / or no longer meet the suitability requirement, within the meaning of procurement law.
In the event that the contract is terminated by ÖW based on serious grounds, ÖW shall only be obliged to remunerate services demonstrably provided up until that point, which have been provided in their entirety and in accordance with the contract, provided that these are still usable by ÖW even after the termination of the contract. ÖW shall acquire rights of use over the deliveries and services rendered up until the time of termination, to the extent provided for in clause 13 of these general contractual and payment conditions.
10. Non-Disclosure
The Contractor shall be obliged to maintain strict confidentiality with respect to all trade and commercial secrets of the Principal and its clients, entrusted to it or which have otherwise become known to it in the course of the contractual cooperation, in particular as unprotected practical knowledge (know-how), towards third parties and to refrain from, either directly or indirectly, exploiting this knowledge itself for through third parties. Furthermore, the contractor undertakes to use information only on a "need to know" basis and only within the framework of the concluded contract.
This obligation of confidentiality in particular also encompass the conclusion and content of contracts entered into with ÖW, as well as all circumstances and information pertaining to individual orders.
The Contractor shall be obliged to impose on its employees and / or any third parties, which have been engaged by it for the purpose of implementing the project, a corresponding confidentiality obligation and to provide evidence of this to ÖW, at the latter's behest, by providing copies of these agreements.
All documents, drafts, templates etc., made available to the contractor, by ÖW or its clients, for the implementation of the contract, shall be promptly returned to ÖW, undamaged and without being requested to do so, upon completion of the respective contract. The production of physical or electronic copies shall only be permissible after consultation with ÖW. Any produced copies must be destroyed and / or deleted following the completion of the contract. The contractor shall, for whatever reason, not be entitled to a right of retention.
This obligation of confidentiality shall continue to apply even after the implementation of the individual contracts.
In case of a violation of the confidentiality obligation, the contractor shall be liable to pay to ÖW a contractual penalty, irrespective of fault, per violation, amounting to 10% of the net contract value. All other claims by ÖW, of whatever kind, shall remain unaffected by this contractual penalty, which constitutes minimum compensation.
Advertising and publications about orders from ÖW, as well as the inclusion of ÖW in the contractor's reference list, require the prior written consent of ÖW.
11. Employment of workersIn the event that workers are hired or contracts for work labour are entered into by the contractor, in the course of the fulfilment of the contract, the contractor shall act as the employer and conclude employment contracts and / or contracts for work labour in its own name at its own expense and shall take on the obligations resulting therefrom. The Contractor shall be liable for the culpable misconduct of all persons used by it in the course of the fulfilment of its contractual obligations, to the same extent as it would be for its own culpable misconduct.
The Contractor shall oblige its employees to comply with the provisions of the Data Protection Act and GDPR. The contractor hereby also confirms that all employees commissioned with data processing are subject to an obligation of confidentiality that remains in effect even after their work with the contractor has ended.
13. Invoicing and payment
In the absence of individual written agreements to the contrary, the remuneration shall be paid to the Contractor within 30 days, following the receipt by ÖW of an appropriate and verifiable invoice, faultless performance and/or delivery and possible acceptance, pursuant to clause 6.3.
For the calculation of the due date for payment, deliveries and / or performances, which have been rendered before the agreed date of delivery and / or performance shall only be deemed as having been received at the time of the agreed delivery and / or performance date.
A notification of defects by ÖW shall interrupt the payment deadline for the invoice, pursuant to paragraph 1 of this provision.
Customs, legal fees, taxes (excluding corporate tax to be paid by ÖW), delivery and transportation costs, and packaging costs shall be borne by the contractor. All prices are listed in euros and are exclusive of value added tax.
The agreed fixed prices include all services that are necessary for the proper fulfilment of the contract, in particular any installation and documentation costs, costs for any license fees, packaging, transport, insurance and unloading costs, public fees and charges, as well as social benefits and expenses.
ÖW shall be entitled to retain and / or deduct from the invoice of the contractor any payment of taxes, not payable by ÖW, which are deducted by the competent authority and / or should be retained by ÖW. Proof of such tax payments, by providing relevant documents, shall be made available to the contractor upon request.
The parties agree that Vienna shall be the place of payment and performance.
14. Proprietary rights
The contractor shall be obliged to ensure that all services it provides are free from any proprietary rights of third parties and/or that it has the authority to transfer the corresponding usufructuary rights to ÖW.
The Contractor shall indemnify and hold harmless ÖW, from and against, any and all third party claims, which are brought against ÖW, owing to a use of the service provided by the Contractor. The foregoing is without prejudice to ÖW's right to claim damages and rescind the contract, in accordance with statutory provisions.
All copyrights, industrial property rights and other physical or intellectual property rights to the contractual service provided and to all other documents, machine-readable as well as other work results achieved within the framework of individual contracts, arising in the course of the execution of the contract shall pass to ÖW upon their creation, without further conditions and without additional charges. These rights shall exclusively belong to ÖW, without any restrictions in terms of territory, time or content and may be extended, transferred, modified, adapted, amended, duplicated or published by ÖW without Contractor's consent. Semi-finished products (printed films, excluding geographical maps) shall become the property of ÖW and ÖW shall have the rights to use these to the extent mentioned above.
15. Severability Clause
Should any provision of these general contractual and payment conditions and any future contracts concluded on the basis thereof be or become invalid, this shall not affect the validity of the remaining provisions of these general conditions of purchase and/or the contract. The contracting parties agree to make all reasonable efforts to replace the invalid provision with one which, to the greatest extent possible, achieves the intended commercial result of the original provision.
16. Formal requirements and offsetting
Changes or additions to the contract must be made in writing. This also applies to changes to the written form requirement.
Offsetting against claims by ÖW with counterclaims of any kind is not permitted.
17. Choice of Law and Jurisdiction
The contract shall be exclusively governed by Austrian law, to the exclusion of the reference norms of the Austrian Private International Law Act (IPRG) and the UN sales law. The contracting parties hereby agree that the respective competent court within the jurisdictional district of the First District of Vienna, shall have exclusive jurisdiction over any disputes arising from or in connection with the contract.
Data Protection & Terms of Use


Pakistan International Cockpit Film – The place to download Just Planes Videos!
In 2012 a Just Planes team spent a week in Pakistan to capture the aircraft and some of the routes operated by PIA. The mission here was to give viewers a look at aviation and flight operations in the country. We're happy to welcome Pakistan International Airlines, the 273rd airline in our seriews! You will be treated to flights on the older classic generation 737 and 747 to the newer generation 777 with few presentations but lots of visuals.
Highlights of the program include the ATR-42 flight to Gilgit, a hub for mountaineering expeditions in Northern Pakistan. Gilgit has a short runway (1600m) located at the edge of a slope.
Skardu has a longer runway but at an altitude of over 8000 feet and surrounded by mountains the final approach is very complicated as you enter into the valley with sharp turns and obstacles on both sides. Our flight from Islamabad and back operates on the Boeing 737 classic 300 version.
Last but not least is a chance to fly one of the last passenger 747 classic aircraft and one of the last cockpits manned by a Flight Engineer. Only 81 -300s were built with just about none left in passenger service today!
Great video especially the Skardu ops with the 737 and Gilgit.Also included is a whole flight on AP-BHO the same aircraft that crashed a few years later, very eerie RIP passengers and crew.
Great atc and excellent views really enjoyed this unseen footage of PIA operations previously not seen.


text:
Browse: Home / 2016 / August / FEMA Hosts Sept. 8 Flood-Risk Open House in St. Charles
FEMA Hosts Sept. 8 Flood-Risk Open House in St. Charles
kanecountyconnects / August 31, 2016 / Leave a comment / Communities, Government, Homeowners, Public Safety
Representatives from the U.S. Department of Homeland Security's Federal Emergency Management Agency are hosting a Flood Risk Information Open House from 5 to 7 p.m. Thursday, Sept. 8, 2016, in the City Council Chambers, 2 East Main Street in St. Charles.
The open house will provide St. Charles residents an opportunity to review the preliminary Flood Insurance Study and Flood Insurance Rate Maps for the 7th Avenue Creek area. Digital copies of the FIRM and FIS materials also are available on FEMA's website www.fema.gov/preliminaryfloodhazarddata or on the city's 7th Avenue Creek project website at www.stcharlesil.gov/projects/7th-avenue-creek-project.
The FIS and the FIRMs provide base flood information, delineate areas subject to significant flood hazards within Kane County, and offer information public officials may use when permitting development in the floodplain.
The Open House will be staffed with representatives from various local, state and federal agencies who will provide the most current information about flood risk, flood insurance, floodplain development regulations, and the process for floodplain mapping within Kane County. The newly prepared preliminary floodplain maps will be on display.
Once the maps become effective, these maps will be used by floodplain permit officials, builders and developers, lenders, realtors, insurance agents and the general public to determine flood risk, develop mitigation measures, and encourage wise and responsible risk management decision-making.
Property owners, real estate agents, lenders and insurance agents are urged to attend and take advantage of this opportunity to learn more about flood risk and hazard mitigation within their community. For more information, contact Ken Hinterlong, FEMA Region V at Ken.Hinterlong@fema.dhs.gov or 312-408-5529.
About FEMA
FEMA's mission is to support our citizens and first responders to ensure that as a nation we work together to build, sustain, and improve our capability to prepare for, protect against, respond to, recover from, and mitigate all hazards.
About the City of St. Charles
Friendly neighborhoods, diverse retailers, international employers, innovative schools, beautiful parks, varied cultural amenities, and unique architecture have earned St. Charles its reputation as the Pride of the Fox. Located in both DuPage and Kane counties, the City of St. Charles is 35 miles west of downtown Chicago, and has a population of approximately 33,000. Over 1,800 businesses, consisting of a balanced mix of retailers, restaurants and manufacturing facilities, employ more than 18,000 people. The City of St. Charles was named the #1 City for Families by Family Circle® magazine in 2011; one of the "150 Great Places in Illinois," by the AIA Illinois; and one of the "Top 10 Towns To Live In" by West Suburban Living magazine. www.stcharlesil.gov
Tags: FEMA, Flood Risk, IL, Kane County, Open House
← Elgin Heritage Commission's Cool, Interactive Website Receives 'Historic' National Award
Clerk's Office Begins Promotional Campaign for Early Voting in November Election →

redpajama_set_name: RedPajamaCommonCrawl


When writing Lizzy & Jane, I had the pleasure of combining my adoration for cooking and literature in a love story. This particular recipe, a personal favorite and one I pull out every fall, is the first meal Elizabeth creates for Jane and her family in the story. And while it is a wonderful dish, in Lizzy & Jane it illustrates the vast gulf between the sisters and is less successful than Elizabeth hoped or anticipated. I suspect that if we returned to the recipe near the end of the book, Lizzy would know just how to "tweak" it to satisfy Jane. But we do not see it again, because Lizzy is no longer focused on the past, but on her sister and Jane's present needs.
This recipe was inspired by Joanne Glynn's Slow Cooking: Not So Fast Food (Whitecap: 2010) – a gem of a book! In our hungry family, this recipe feeds five perfectly. I always serve this dish with petite peas. Enjoy!
A recipe for Shepherd's Pie, a comfort food classic from author Katherine Reay, paired with her novel, LIZZY AND JANE.
Heat half of the oil in a large saucepan and add the onions, garlic and carrots. Cook over a moderate heat until softened. Set aside.
Add remaining oil to the pan, add the meat and cook until lightly colored, approximately 7 minutes. Sprinkle with the flour, stir, and cook for an additional minute.
Add the broth, tomato paste, Worcestershire sauce, seasoning, parsley, cinnamon, nutmeg, and bay leaf and stir. Add the onion mixture, stir and bring to boil, then gently simmer over a low heat for 45 minutes. Add a little more broth if it becomes dry. Remove bay leaf.
Preheat oven to 350°F. Peel the potatoes and cut into 1-inch pieces. Place potatoes into a large saucepan of salted water and bring to boil. Cook over moderate heat for 15-20 minutes or until soft. Drain potatoes, return them to the pan, add butter, and mash with a little milk. The mash needs to remain firm. Beat with a wooden spoon to make potatoes fluffy.
Spoon the meat filling into a lasagna size pan. Spread the mash over the top. Fluff the mash with a fork. Bake for 35-40 minutes or until the topping is golden.
In my novel, LIZZY & JANE and in my house, lamb (making it Shepherd's Pie) or a combination of beef and lamb (making, perhaps, "Shepage" Pie) is used. Any meat combination is yummy.
Also, my middle child eats gluten-free so I substitute a gluten-free flour for the all-purpose and it too works beautifully.


text:
Why AHCI
HealthChoices/Medicaid
Assertive Community Treatment
Systems Planning & Development
MHFA Instructors
Recovery Initiatives
Allegheny HealthChoices Program: Summaries
MAT Locator
Allegheny HealthChoices, Inc.
Email: webmaster@ahci.org
Recorder for Clinical Programs and Practices
Allegheny HealthChoices, Inc. (AHCI) is a non-profit located in downtown Pittsburgh with a mission to assure equitable access to quality, cost-effective behavioral health care that promotes positive clinical outcomes, recovery, and resiliency. Formed in 1999, AHCI's role has evolved from monitoring and oversight to that of a partner and consultant in system planning and evaluation, project management, data management and analysis, and recovery.
Community Support Planning (CSP) is a collaborative process that provides an opportunity for individuals residing in a supervised environment to express their needs and wants. This is process works toward developing strategies and securing resources to support the person for successful transition and living in the community. The CSP Process promotes independence and recovery through hope, empowerment, and coordinated care. The Recorder is a valuable member of the team that assists all meeting participants to focus on tasks associated with the development of the CSP. The Recorder keeps detailed notes and completes the comprehensive plan while being organized, demonstrating strong writing skills, and with a focus on mental health and recovery principles. The ideal candidate will need to have reliable transportation to multiple sites, including Torrance State Hospital. Flexibility will also be critical as there will be a varying schedule and number of hours, although, on average, candidates can expect about 40-80 hours per month. This person reports to the Manager of Program Consultation and interfaces with consumers of behavioral health services, network providers, funders, and other stakeholders on a regular basis.
ESSENTIAL DUTIES AND RESPONSIBILITIES (Other duties may be assigned.)
Attend planning meetings in a variety of mental health and residential facilities.
Successfully collaborate with all members of the CSP process to foster a culture of engagement and creative problem solving.
Offer objectivity through review of assessments, keen observation, and thorough documentation.
Ensure timely completion of Community Support Plans within 3 business days of the final planning meeting.
Bachelor's degree in human services related field or related discipline or equivalent work experience.
Ability to meet deadlines, manage multiple tasks, maintain confidentiality for sensitive materials, be flexible and dependable, empathic, and work with a diverse, multicultural audience.
Superior written and organizational skills with minimal supervision to complete work in a timely manner.
Superior listening skills to identify important content during meetings, identify tasks, and transfer information into the Community Support Plan document.
Knowledge of Microsoft Office, including Word, Outlook, and basic Excel.
Qualified candidates should send a resume via email to jobs@acuity-hr.com with "CSP Recorder" in the subject line, or mail their resume and cover letter to:
Cranberry Twp., PA 16066
444 Liberty Avenue, Suite 240
Email webmaster@ahci.org
Fraud, Waste, and Abuse
Copyright © 2021 AHCI. All rights reserved.


Since its humble beginnings as a small scale company in 1975, Garber Metrology has grown to become one of the premier Weighing Equipment/Calibration Companies in the Mid-Atlantic Region. Today the company operates two distinct but closely connected divisions: Weighing Solutions and Calibration/Metrology Services.
Garber Metrology is one of the region's largest distributors of weighing equipment, representing many of the industry's most prestigious manufacturers. Garber sells a wide array of weighing equipment, from precision laboratory balances with accuracies in milligrams, to truck and railroad scales with capacities exceeding 250 tons. Garber Metrology retains the experience and expertise to calibrate, troubleshoot, and repair all of the equipment we sell in addition to providing custom programming solutions and maintaining a fleet of rental equipment.
Calibration/Metrology services are delivered via our in-house laboratories (including our temperature and humidity controlled physical/dimensional lab), and on-site at our customers' facilities. These services cover a wide range of instruments, gages, and equipment.
Garber Metrology maintains the highest levels of quality and is ISO 9001 Registered, and ISO/IEC 17025 and ANSI/NCSL Z540-1-1994 Accredited through ANAB. The company's scope of accreditation is broad, encompassing dimensional, mechanical, electromagnetic DC/low frequency, and thermodynamic disciplines.
Garber Metrology is one of the only companies in the Mid-Atlantic Region that combines full service weighing solutions, a wide range of calibration/metrology services and a broad scope of accreditation.


We would like to match your property with the perfect solar electric system.
Please, fill out the following information and our expert will contact you.
Along with saving on your electric bill, solar panels provide additional savings with solar renewable energy credits (SRECs). Owning a solar electric system provides a significant increase in resale value for your home or business. Invest a little today and save for years to come.
The Federal government offers a 30% federal income tax credit which applies to the total cost of the system. Additional state and local rebates may be available which help reduce total costs significantly.
Electric utility rates will continue to increase over time. Installing your own solar electric system reduces your dependence on the power company and can make rate increases irrelevant.
Solar panel manufacturers provide a 25 year warranty. All major components of the system are designed to last at least 20 years relatively maintenance free. As an installer we provide a 10 year installation guarantee. In turn provides you a long lasting worry free installation.


text:
package org.pentaho.di.core.row;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;

import junit.framework.Assert;
import junit.framework.TestCase;

import org.apache.commons.lang.StringUtils;
import org.junit.Test;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.util.Utils;
import org.pentaho.di.core.exception.KettleValueException;
import org.pentaho.di.core.row.value.ValueMetaInteger;
import org.pentaho.di.core.row.value.ValueMetaString;
import org.pentaho.di.trans.steps.calculator.CalculatorMetaFunction;

/**
 * Not yet completely finished.
 *
 * @author sboden
 *
 */
public class ValueDataUtilBackwardCompatibilityIT extends TestCase {
  private static String yyyy_MM_dd = "yyyy-MM-dd";

  private static final String SYS_PROPERTY_ROUND_2_MODE = "ROUND_2_MODE";
  private static final int OBSOLETE_ROUND_2_MODE = BigDecimal.ROUND_HALF_EVEN;
  private static final int DEFAULT_ROUND_2_MODE = Const.ROUND_HALF_CEILING;
  private static final int ORIGINAL_ROUND_2_MODE = getRound2Mode();

  @Override
  protected void setUp() throws Exception {
    assertEquals(DEFAULT_ROUND_2_MODE, getRound2Mode());
    setRound2Mode( OBSOLETE_ROUND_2_MODE );
    assertEquals(OBSOLETE_ROUND_2_MODE, getRound2Mode());
  }

  @Override
  protected void tearDown() throws Exception {
    setRound2Mode( ORIGINAL_ROUND_2_MODE );
    assertEquals(DEFAULT_ROUND_2_MODE, getRound2Mode());
  }

  /**
   * Get value of private static field ValueDataUtil.ROUND_2_MODE.
   *
   * @return
   */
  private static int getRound2Mode() {
    int value = -1;
    try {
      Class<ValueDataUtil> cls = ValueDataUtil.class;
      Field f = cls.getDeclaredField( SYS_PROPERTY_ROUND_2_MODE );
      f.setAccessible( true );
      value = (Integer) f.get( null );
      f.setAccessible( false );
    } catch ( Exception e ) {
      throw new RuntimeException( e );
    }
    return value;
  }

  /**
   * Set new value of value of private static field ValueDataUtil.ROUND_2_MODE.
   *
   * @param newValue
   */
  private static void setRound2Mode( int newValue ) {
    try {
      Class<ValueDataUtil> cls = ValueDataUtil.class;
      Field f = cls.getDeclaredField( SYS_PROPERTY_ROUND_2_MODE );
      f.setAccessible( true );
      f.set( null, newValue );
      f.setAccessible( false );
    } catch ( Exception e ) {
      throw new RuntimeException( e );
    }
  }

  // private enum DateCalc {WORKING_DAYS, DATE_DIFF};

  /**
   * @deprecated Use {@link Const#ltrim(String)} instead
   * @throws KettleValueException
   */
  @Deprecated
  public void testLeftTrim() throws KettleValueException {
    assertEquals( "", ValueDataUtil.leftTrim( "" ) );
    assertEquals( "string", ValueDataUtil.leftTrim( "string" ) );
    assertEquals( "string", ValueDataUtil.leftTrim( " string" ) );
    assertEquals( "string", ValueDataUtil.leftTrim( "  string" ) );
    assertEquals( "string", ValueDataUtil.leftTrim( "   string" ) );
    assertEquals( "string", ValueDataUtil.leftTrim( "     string" ) );

    assertEquals( "string ", ValueDataUtil.leftTrim( " string " ) );
    assertEquals( "string  ", ValueDataUtil.leftTrim( "  string  " ) );
    assertEquals( "string   ", ValueDataUtil.leftTrim( "   string   " ) );
    assertEquals( "string    ", ValueDataUtil.leftTrim( "    string    " ) );

    assertEquals( "", ValueDataUtil.leftTrim( " " ) );
    assertEquals( "", ValueDataUtil.leftTrim( "  " ) );
    assertEquals( "", ValueDataUtil.leftTrim( "   " ) );
  }

  /**
   * @deprecated Use {@link Const#rtrim(String)} instead
   * @throws KettleValueException
   */
  @Deprecated
  public void testRightTrim() throws KettleValueException {
    assertEquals( "", ValueDataUtil.rightTrim( "" ) );
    assertEquals( "string", ValueDataUtil.rightTrim( "string" ) );
    assertEquals( "string", ValueDataUtil.rightTrim( "string " ) );
    assertEquals( "string", ValueDataUtil.rightTrim( "string  " ) );
    assertEquals( "string", ValueDataUtil.rightTrim( "string   " ) );
    assertEquals( "string", ValueDataUtil.rightTrim( "string    " ) );

    assertEquals( " string", ValueDataUtil.rightTrim( " string " ) );
    assertEquals( "  string", ValueDataUtil.rightTrim( "  string  " ) );
    assertEquals( "   string", ValueDataUtil.rightTrim( "   string   " ) );
    assertEquals( "    string", ValueDataUtil.rightTrim( "    string    " ) );

    assertEquals( "", ValueDataUtil.rightTrim( " " ) );
    assertEquals( "", ValueDataUtil.rightTrim( "  " ) );
    assertEquals( "", ValueDataUtil.rightTrim( "   " ) );
  }

  /**
   * @deprecated Use {@link Const#isSpace(char)} instead
   * @throws KettleValueException
   */
  @Deprecated
  public void testIsSpace() throws KettleValueException {
    assertTrue( ValueDataUtil.isSpace( ' ' ) );
    assertTrue( ValueDataUtil.isSpace( '\t' ) );
    assertTrue( ValueDataUtil.isSpace( '\r' ) );
    assertTrue( ValueDataUtil.isSpace( '\n' ) );

    assertFalse( ValueDataUtil.isSpace( 'S' ) );
    assertFalse( ValueDataUtil.isSpace( 'b' ) );
  }

  /**
   * @deprecated Use {@link Const#trim(String)} instead
   * @throws KettleValueException
   */
  @Deprecated
  public void testTrim() throws KettleValueException {
    assertEquals( "", ValueDataUtil.trim( "" ) );
    assertEquals( "string", ValueDataUtil.trim( "string" ) );
    assertEquals( "string", ValueDataUtil.trim( "string " ) );
    assertEquals( "string", ValueDataUtil.trim( "string  " ) );
    assertEquals( "string", ValueDataUtil.trim( "string   " ) );
    assertEquals( "string", ValueDataUtil.trim( "string    " ) );

    assertEquals( "string", ValueDataUtil.trim( " string " ) );
    assertEquals( "string", ValueDataUtil.trim( "  string  " ) );
    assertEquals( "string", ValueDataUtil.trim( "   string   " ) );
    assertEquals( "string", ValueDataUtil.trim( "    string    " ) );

    assertEquals( "string", ValueDataUtil.trim( " string" ) );
    assertEquals( "string", ValueDataUtil.trim( "  string" ) );
    assertEquals( "string", ValueDataUtil.trim( "   string" ) );
    assertEquals( "string", ValueDataUtil.trim( "    string" ) );

    assertEquals( "", ValueDataUtil.rightTrim( " " ) );
    assertEquals( "", ValueDataUtil.rightTrim( "  " ) );
    assertEquals( "", ValueDataUtil.rightTrim( "   " ) );
  }

  public void testDateDiff_A_GT_B() {
    Object daysDiff =
      calculate( "2010-05-12", "2010-01-01", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_DATE_DIFF );
    assertEquals( new Long( 131 ), daysDiff );
  }

  public void testDateDiff_A_LT_B() {
    Object daysDiff =
      calculate( "2010-12-31", "2011-02-10", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_DATE_DIFF );
    assertEquals( new Long( -41 ), daysDiff );
  }

  public void testWorkingDaysDays_A_GT_B() {
    Object daysDiff =
      calculate(
        "2010-05-12", "2010-01-01", ValueMetaInterface.TYPE_DATE,
        CalculatorMetaFunction.CALC_DATE_WORKING_DIFF );
    assertEquals( new Long( 93 ), daysDiff );
  }

  public void testWorkingDaysDays_A_LT_B() {
    Object daysDiff =
      calculate(
        "2010-12-31", "2011-02-10", ValueMetaInterface.TYPE_DATE,
        CalculatorMetaFunction.CALC_DATE_WORKING_DIFF );
    assertEquals( new Long( -29 ), daysDiff );
  }

  @Test
  public void testPlus() throws KettleValueException {

    long longValue = 1;

    assertEquals( longValue, ValueDataUtil.plus( new ValueMetaInteger(), longValue, new ValueMetaString(), StringUtils.EMPTY ) );

  }

  public void testAdd() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "3.0" ), calculate(
      "1", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Double.valueOf( "0.0" ), calculate(
      "2", "-2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Double.valueOf( "30.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Double.valueOf( "-50.0" ), calculate(
      "-100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "3" ), calculate(
      "1", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Long.valueOf( "0" ), calculate(
      "2", "-2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Long.valueOf( "30" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD ) );
    assertEquals( Long.valueOf( "-50" ), calculate(
      "-100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "2.0" ).compareTo( (BigDecimal) calculate(
      "1", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD ) ) );
    assertEquals( 0, new BigDecimal( "0.0" ).compareTo( (BigDecimal) calculate(
      "2", "-2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD ) ) );
    assertEquals( 0, new BigDecimal( "30.0" ).compareTo( (BigDecimal) calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD ) ) );
    assertEquals( 0, new BigDecimal( "-50.0" ).compareTo( (BigDecimal) calculate(
      "-100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD ) ) );
  }

  public void testAdd3() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "6.0" ), calculate(
      "1", "2", "3", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Double.valueOf( "10.0" ), calculate(
      "2", "-2", "10", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Double.valueOf( "27.0" ), calculate(
      "10", "20", "-3", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Double.valueOf( "-55.0" ), calculate(
      "-100", "50", "-5", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_ADD3 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "3" ), calculate(
      "1", "1", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Long.valueOf( "10" ), calculate(
      "2", "-2", "10", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Long.valueOf( "27" ), calculate(
      "10", "20", "-3", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD3 ) );
    assertEquals( Long.valueOf( "-55" ), calculate(
      "-100", "50", "-5", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_ADD3 ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "6.0" ).compareTo( (BigDecimal) calculate(
      "1", "2", "3", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD3 ) ) );
    assertEquals( 0, new BigDecimal( "10.0" ).compareTo( (BigDecimal) calculate(
      "2", "-2", "10", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD3 ) ) );
    assertEquals( 0, new BigDecimal( "27.0" ).compareTo( (BigDecimal) calculate(
      "10", "20", "-3", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD3 ) ) );
    assertEquals( 0, new BigDecimal( "-55.0" ).compareTo( (BigDecimal) calculate(
      "-100", "50", "-5", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ADD3 ) ) );
  }

  public void testSubtract() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "10.0" ), calculate(
      "20", "10", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_SUBTRACT ) );
    assertEquals( Double.valueOf( "-10.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_SUBTRACT ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "10" ), calculate(
      "20", "10", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_SUBTRACT ) );
    assertEquals( Long.valueOf( "-10" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_SUBTRACT ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "10" ).compareTo( (BigDecimal) calculate(
      "20", "10", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_SUBTRACT ) ) );
    assertEquals( 0, new BigDecimal( "-10" ).compareTo( (BigDecimal) calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_SUBTRACT ) ) );
  }

  public void testDivide() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "2.0" ), calculate(
      "2", "1", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Double.valueOf( "2.0" ), calculate(
      "4", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Double.valueOf( "0.5" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Double.valueOf( "2.0" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "2" ), calculate(
      "2", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "4", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Long.valueOf( "0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_DIVIDE ) );

    // Test Kettle big Number types
    assertEquals( BigDecimal.valueOf( Long.valueOf( "2" ) ), calculate(
      "2", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( BigDecimal.valueOf( Long.valueOf( "2" ) ), calculate(
      "4", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "0.5" ) ), calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
    assertEquals( BigDecimal.valueOf( Long.valueOf( "2" ) ), calculate(
      "100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_DIVIDE ) );
  }

  public void testPercent1() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "10.0" ), calculate(
      "10", "100", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Double.valueOf( "100.0" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Double.valueOf( "50.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Double.valueOf( "200.0" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "10" ), calculate(
      "10", "100", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Long.valueOf( "100" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Long.valueOf( "50" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( Long.valueOf( "200" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_1 ) );

    // Test Kettle big Number types
    assertEquals( BigDecimal.valueOf( Long.valueOf( "10" ) ), calculate(
      "10", "100", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( BigDecimal.valueOf( Long.valueOf( "100" ) ), calculate(
      "2", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( BigDecimal.valueOf( Long.valueOf( "50" ) ), calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
    assertEquals( BigDecimal.valueOf( Long.valueOf( "200" ) ), calculate(
      "100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_1 ) );
  }

  public void testPercent2() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "0.99" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Double.valueOf( "1.96" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Double.valueOf( "8.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Double.valueOf( "50.0" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Long.valueOf( "8" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( Long.valueOf( "50" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_2 ) );

    // Test Kettle big Number types
    assertEquals( BigDecimal.valueOf( Double.valueOf( "0.99" ) ), calculate(
      "1", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1.99" ) ), calculate(
      "2", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "9.995" ) ), calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "99.98" ) ), calculate(
      "100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_2 ) );
  }

  public void testPercent3() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "1.01" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Double.valueOf( "2.04" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Double.valueOf( "12.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Double.valueOf( "150.0" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Long.valueOf( "12" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_3 ) );
    assertEquals( Long.valueOf( "150" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_PERCENT_3 ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "1.01" ).compareTo( (BigDecimal) calculate(
      "1", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) ) );
    assertEquals( 0, new BigDecimal( "2.01" ).compareTo( (BigDecimal) calculate(
      "2", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) ) );
    assertEquals( 0, new BigDecimal( "10.005" ).compareTo( (BigDecimal) calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) ) );
    assertEquals( 0, new BigDecimal( "100.02" ).compareTo( (BigDecimal) calculate(
      "100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_PERCENT_3 ) ) );
  }

  public void testCombination1() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "2.0" ), calculate(
      "1", "1", "1", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Double.valueOf( "22.0" ), calculate(
      "2", "2", "10", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Double.valueOf( "70.0" ), calculate(
      "10", "20", "3", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Double.valueOf( "350" ), calculate(
      "100", "50", "5", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "2" ), calculate(
      "1", "1", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Long.valueOf( "22" ), calculate(
      "2", "2", "10", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Long.valueOf( "70" ), calculate(
      "10", "20", "3", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );
    assertEquals( Long.valueOf( "350" ), calculate(
      "100", "50", "5", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_1 ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "2.0" ).compareTo( (BigDecimal) calculate(
      "1", "1", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) ) );
    assertEquals( 0, new BigDecimal( "22.0" ).compareTo( (BigDecimal) calculate(
      "2", "2", "10", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) ) );
    assertEquals( 0, new BigDecimal( "70.0" ).compareTo( (BigDecimal) calculate(
      "10", "20", "3", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) ) );
    assertEquals( 0, new BigDecimal( "350.0" ).compareTo( (BigDecimal) calculate(
      "100", "50", "5", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_1 ) ) );
  }

  public void testCombination2() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "1.4142135623730951" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Double.valueOf( "2.8284271247461903" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Double.valueOf( "22.360679774997898" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Double.valueOf( "111.80339887498948" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate(
      "1", "1", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "2", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Long.valueOf( "10" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );
    assertEquals( Long.valueOf( "100" ), calculate(
      "100", "50", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_COMBINATION_2 ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "1.4142135623730951" ).compareTo( (BigDecimal) calculate(
      "1", "1", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) ) );
    assertEquals( 0, new BigDecimal( "2.8284271247461903" ).compareTo( (BigDecimal) calculate(
      "2", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) ) );
    assertEquals( 0, new BigDecimal( "22.360679774997898" ).compareTo( (BigDecimal) calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) ) );
    assertEquals( 0, new BigDecimal( "111.80339887498948" ).compareTo( (BigDecimal) calculate(
      "100", "50", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_COMBINATION_2 ) ) );
  }

  public void testRound() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "1.0" ), calculate( "1", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Double.valueOf( "103.0" ), calculate( "103.01", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Double.valueOf( "1235.0" ), calculate( "1234.6", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    // half
    assertEquals( Double.valueOf( "1235.0" ), calculate( "1234.5", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Double.valueOf( "1236.0" ), calculate( "1235.5", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Double.valueOf( "-1234.0" ), calculate( "-1234.5", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Double.valueOf( "-1235.0" ), calculate( "-1235.5", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate( "1", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Long.valueOf( "2" ), calculate( "2", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( Long.valueOf( "-103" ), calculate( "-103", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );

    // Test Kettle big Number types
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1.0" ) ), calculate( "1", ValueMetaInterface.TYPE_BIGNUMBER,
        CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "103.0" ) ), calculate( "103.01",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1235.0" ) ), calculate( "1234.6",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
    // half
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1235.0" ) ), calculate( "1234.5",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1236.0" ) ), calculate( "1235.5",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "-1234.0" ) ), calculate( "-1234.5",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "-1235.0" ) ), calculate( "-1235.5",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_1 ) );
  }

  public void testRound2() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "1.0" ), calculate( "1", "1", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "2.1" ), calculate( "2.06", "1", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "103.0" ), calculate( "103.01", "1", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "12.35" ), calculate( "12.346", "2", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    // scale < 0
    assertEquals( Double.valueOf( "10.0" ), calculate( "12.0", "-1", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    // half
    assertEquals( Double.valueOf( "12.34" ), calculate( "12.345", "2", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "12.36" ), calculate( "12.355", "2", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "-12.34" ), calculate( "-12.345", "2", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Double.valueOf( "-12.36" ), calculate( "-12.355", "2", ValueMetaInterface.TYPE_NUMBER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate( "1", "1", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Long.valueOf( "2" ), calculate( "2", "2", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Long.valueOf( "103" ), calculate( "103", "3", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( Long.valueOf( "12" ), calculate( "12", "4", ValueMetaInterface.TYPE_INTEGER,
        CalculatorMetaFunction.CALC_ROUND_2 ) );
    // scale < 0
    //assertEquals( Long.valueOf( "100" ), calculate( "120", "-2", ValueMetaInterface.TYPE_INTEGER,
    //    CalculatorMetaFunction.CALC_ROUND_2 ) );
    // half
    //assertEquals( Long.valueOf( "12340" ), calculate( "12345", "-1", ValueMetaInterface.TYPE_INTEGER,
    //    CalculatorMetaFunction.CALC_ROUND_2 ) );
    //assertEquals( Long.valueOf( "12360" ), calculate( "12355", "-1", ValueMetaInterface.TYPE_INTEGER,
    //    CalculatorMetaFunction.CALC_ROUND_2 ) );
    //assertEquals( Long.valueOf( "-12340" ), calculate( "-12345", "-1", ValueMetaInterface.TYPE_INTEGER,
    //    CalculatorMetaFunction.CALC_ROUND_2 ) );
    //assertEquals( Long.valueOf( "-12360" ), calculate( "-12355", "-1", ValueMetaInterface.TYPE_INTEGER,
    //    CalculatorMetaFunction.CALC_ROUND_2 ) );

    // Test Kettle big Number types
    assertEquals( BigDecimal.valueOf( Double.valueOf( "1.0" ) ), calculate( "1", "1",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "2.1" ) ), calculate( "2.06", "1",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "103.0" ) ), calculate( "103.01", "1",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "12.35" ) ), calculate( "12.346", "2",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    // scale < 0
    assertEquals( BigDecimal.valueOf( Double.valueOf( "10.0" ) ), calculate( "12.0", "-1",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    // half
    assertEquals( BigDecimal.valueOf( Double.valueOf( "12.34" ) ), calculate( "12.345", "2",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "12.36" ) ), calculate( "12.355", "2",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "-12.34" ) ), calculate( "-12.345", "2",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
    assertEquals( BigDecimal.valueOf( Double.valueOf( "-12.36" ) ), calculate( "-12.355", "2",
        ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_ROUND_2 ) );
  }

  public void testNVL() {

    // Test Kettle number types
    assertEquals( Double.valueOf( "1.0" ), calculate(
      "1", "", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( Double.valueOf( "2.0" ), calculate(
      "", "2", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( Double.valueOf( "10.0" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( null, calculate( "", "", ValueMetaInterface.TYPE_NUMBER, CalculatorMetaFunction.CALC_NVL ) );

    // Test Kettle string types
    assertEquals( "1", calculate( "1", "", ValueMetaInterface.TYPE_STRING, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( "2", calculate( "", "2", ValueMetaInterface.TYPE_STRING, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( "10", calculate( "10", "20", ValueMetaInterface.TYPE_STRING, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( null, calculate( "", "", ValueMetaInterface.TYPE_STRING, CalculatorMetaFunction.CALC_NVL ) );

    // Test Kettle Integer (Java Long) types
    assertEquals( Long.valueOf( "1" ), calculate(
      "1", "", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( Long.valueOf( "2" ), calculate(
      "", "2", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( Long.valueOf( "10" ), calculate(
      "10", "20", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( null, calculate( "", "", ValueMetaInterface.TYPE_INTEGER, CalculatorMetaFunction.CALC_NVL ) );

    // Test Kettle big Number types
    assertEquals( 0, new BigDecimal( "1" ).compareTo( (BigDecimal) calculate(
      "1", "", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_NVL ) ) );
    assertEquals( 0, new BigDecimal( "2" ).compareTo( (BigDecimal) calculate(
      "", "2", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_NVL ) ) );
    assertEquals( 0, new BigDecimal( "10" ).compareTo( (BigDecimal) calculate(
      "10", "20", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_NVL ) ) );
    assertEquals( null, calculate( "", "", ValueMetaInterface.TYPE_BIGNUMBER, CalculatorMetaFunction.CALC_NVL ) );

    // boolean
    assertEquals( true, calculate( "true", "", ValueMetaInterface.TYPE_BOOLEAN, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( false, calculate( "", "false", ValueMetaInterface.TYPE_BOOLEAN, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( false, calculate(
      "false", "true", ValueMetaInterface.TYPE_BOOLEAN, CalculatorMetaFunction.CALC_NVL ) );
    assertEquals( null, calculate( "", "", ValueMetaInterface.TYPE_BOOLEAN, CalculatorMetaFunction.CALC_NVL ) );

    // Test Kettle date
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat( yyyy_MM_dd );

    try {
      assertEquals( simpleDateFormat.parse( "2012-04-11" ), calculate(
        "2012-04-11", "", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL ) );
      assertEquals( simpleDateFormat.parse( "2012-11-04" ), calculate(
        "", "2012-11-04", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL ) );
      assertEquals( simpleDateFormat.parse( "1965-07-01" ), calculate(
        "1965-07-01", "1967-04-11", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL ) );
      assertNull( calculate( "", "", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL ) );

    } catch ( ParseException pe ) {
      fail( pe.getMessage() );
    }
    // assertEquals(0, calculate("", "2012-11-04", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL)));
    // assertEquals(0, calculate("2012-11-04", "2010-04-11", ValueMetaInterface.TYPE_DATE,
    // CalculatorMetaFunction.CALC_NVL)));
    // assertEquals(null, calculate("", "", ValueMetaInterface.TYPE_DATE, CalculatorMetaFunction.CALC_NVL));

    // binary
    ValueMeta stringValueMeta = new ValueMeta( "string", ValueMeta.TYPE_STRING );
    try {
      byte[] data = stringValueMeta.getBinary( "101" );
      byte[] calculated =
        (byte[]) calculate( "101", "", ValueMetaInterface.TYPE_BINARY, CalculatorMetaFunction.CALC_NVL );
      assertTrue( Arrays.equals( data, calculated ) );

      data = stringValueMeta.getBinary( "011" );
      calculated = (byte[]) calculate( "", "011", ValueMetaInterface.TYPE_BINARY, CalculatorMetaFunction.CALC_NVL );
      assertTrue( Arrays.equals( data, calculated ) );

      data = stringValueMeta.getBinary( "110" );
      calculated =
        (byte[]) calculate( "110", "011", ValueMetaInterface.TYPE_BINARY, CalculatorMetaFunction.CALC_NVL );
      assertTrue( Arrays.equals( data, calculated ) );

      calculated = (byte[]) calculate( "", "", ValueMetaInterface.TYPE_BINARY, CalculatorMetaFunction.CALC_NVL );
      assertNull( calculated );

      // assertEquals(binaryValueMeta.convertData(new ValueMeta("dummy", ValueMeta.TYPE_STRING), "101"),
      // calculate("101", "", ValueMetaInterface.TYPE_BINARY, CalculatorMetaFunction.CALC_NVL));
    } catch ( KettleValueException kve ) {
      fail( kve.getMessage() );
    }
  }

  private Object calculate( String string_dataA, int valueMetaInterfaceType,
      int calculatorMetaFunction ) {
      return calculate( string_dataA, null, null, valueMetaInterfaceType, calculatorMetaFunction );
    }

  private Object calculate( String string_dataA, String string_dataB, int valueMetaInterfaceType,
      int calculatorMetaFunction ) {
      return calculate( string_dataA, string_dataB, null, valueMetaInterfaceType, calculatorMetaFunction );
    }

  private Object calculate( String string_dataA, String string_dataB, String string_dataC,
    int valueMetaInterfaceType, int calculatorMetaFunction ) {

    try {

      //
      ValueMeta parameterValueMeta = new ValueMeta( "parameter", ValueMeta.TYPE_STRING );

      // We create the meta information for
      ValueMeta valueMetaA = createValueMeta( "data_A", valueMetaInterfaceType );
      ValueMeta valueMetaB = createValueMeta( "data_B", valueMetaInterfaceType );
      ValueMeta valueMetaC = createValueMeta( "data_C", valueMetaInterfaceType );

      Object dataA = null;
      Object dataB = null;
      Object dataC = null;

      if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_NUMBER ) {
        dataA = ( !Utils.isEmpty( string_dataA ) ? Double.valueOf( string_dataA ) : null );
        dataB = ( !Utils.isEmpty( string_dataB ) ? Double.valueOf( string_dataB ) : null );
        dataC = ( !Utils.isEmpty( string_dataC ) ? Double.valueOf( string_dataC ) : null );
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_INTEGER ) {
        dataA = ( !Utils.isEmpty( string_dataA ) ? Long.valueOf( string_dataA ) : null );
        dataB = ( !Utils.isEmpty( string_dataB ) ? Long.valueOf( string_dataB ) : null );
        dataC = ( !Utils.isEmpty( string_dataC ) ? Long.valueOf( string_dataC ) : null );
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_DATE ) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat( yyyy_MM_dd );
        try {
          dataA = ( !Utils.isEmpty( string_dataA ) ? simpleDateFormat.parse( string_dataA ) : null );
          dataB = ( !Utils.isEmpty( string_dataB ) ? simpleDateFormat.parse( string_dataB ) : null );
          dataC = ( !Utils.isEmpty( string_dataC ) ? simpleDateFormat.parse( string_dataC ) : null );
        } catch ( ParseException pe ) {
          fail( pe.getMessage() );
          return null;
        }
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_BIGNUMBER ) {
        dataA = ( !Utils.isEmpty( string_dataA ) ? BigDecimal.valueOf( Double.valueOf( string_dataA ) ) : null );
        dataB = ( !Utils.isEmpty( string_dataB ) ? BigDecimal.valueOf( Double.valueOf( string_dataB ) ) : null );
        dataC = ( !Utils.isEmpty( string_dataC ) ? BigDecimal.valueOf( Double.valueOf( string_dataC ) ) : null );
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_STRING ) {
        dataA = ( !Utils.isEmpty( string_dataA ) ? string_dataA : null );
        dataB = ( !Utils.isEmpty( string_dataB ) ? string_dataB : null );
        dataC = ( !Utils.isEmpty( string_dataC ) ? string_dataC : null );
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_BINARY ) {
        ValueMeta binaryValueMeta = new ValueMeta( "binary_data", ValueMeta.TYPE_BINARY );

        dataA =
          ( !Utils.isEmpty( string_dataA )
            ? binaryValueMeta.convertData( parameterValueMeta, string_dataA ) : null );
        dataB =
          ( !Utils.isEmpty( string_dataB )
            ? binaryValueMeta.convertData( parameterValueMeta, string_dataB ) : null );
        dataC =
          ( !Utils.isEmpty( string_dataC )
            ? binaryValueMeta.convertData( parameterValueMeta, string_dataC ) : null );
      } else if ( valueMetaInterfaceType == ValueMetaInterface.TYPE_BOOLEAN ) {
        if ( !Utils.isEmpty( string_dataA ) ) {
          dataA = ( string_dataA.equalsIgnoreCase( "true" ) ? true : false );
        } else {
          dataA = null;
        }
        if ( !Utils.isEmpty( string_dataB ) ) {
          dataB = ( string_dataB.equalsIgnoreCase( "true" ) ? true : false );
        } else {
          dataB = null;
        }
        if ( !Utils.isEmpty( string_dataC ) ) {
          dataC = ( string_dataC.equalsIgnoreCase( "true" ) ? true : false );
        } else {
          dataC = null;
        }
      } else {
        fail( "Invalid ValueMetaInterface type." );
        return null;
      }

      if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ADD ) {
        return ValueDataUtil.plus( valueMetaA, dataA, valueMetaB, dataB );
      }
      if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ADD3 ) {
        return ValueDataUtil.plus3( valueMetaA, dataA, valueMetaB, dataB, valueMetaC, dataC );
      }
      if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_SUBTRACT ) {
        return ValueDataUtil.minus( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DIVIDE ) {
        return ValueDataUtil.divide( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_1 ) {
        return ValueDataUtil.percent1( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_2 ) {
        return ValueDataUtil.percent2( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_PERCENT_3 ) {
        return ValueDataUtil.percent3( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_COMBINATION_1 ) {
        return ValueDataUtil.combination1( valueMetaA, dataA, valueMetaB, dataB, valueMetaC, dataC );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_COMBINATION_2 ) {
        return ValueDataUtil.combination2( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ROUND_1 ) {
        return ValueDataUtil.round( valueMetaA, dataA );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_ROUND_2 ) {
        return ValueDataUtil.round( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_NVL ) {
        return ValueDataUtil.nvl( valueMetaA, dataA, valueMetaB, dataB );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DATE_DIFF ) {
        return ValueDataUtil.DateDiff( valueMetaA, dataA, valueMetaB, dataB, "" );
      } else if ( calculatorMetaFunction == CalculatorMetaFunction.CALC_DATE_WORKING_DIFF ) {
        return ValueDataUtil.DateWorkingDiff( valueMetaA, dataA, valueMetaB, dataB );
      } else {
        fail( "Invalid CalculatorMetaFunction specified." );
        return null;
      }
    } catch ( KettleValueException kve ) {
      fail( kve.getMessage() );
      return null;
    }
  }

  private ValueMeta createValueMeta( String name, int valueType ) {
    ValueMeta valueMeta = new ValueMeta( name, valueType );
    return valueMeta;
  }

  public static void assertEquals(Object expected, Object actual) {
    assertEquals("", expected, actual);
  }
  public static void assertEquals(String msg, Object expected, Object actual) {
    if (expected instanceof BigDecimal && actual instanceof BigDecimal) {
      if (((BigDecimal)expected).compareTo( (BigDecimal)actual ) != 0) {
        Assert.assertEquals( msg, expected, actual );
      }
    } else {
      Assert.assertEquals( msg, expected, actual );
    }
  }
}

redpajama_set_name: RedPajamaGithub


Michael Schwab is one of America's most recognized and respected visual creators. He is a designer, an illustrator, and an artist. His work is simple, concise, dramatic, and iconic.His clients include: Nike, Polo, Wells Fargo, Amtrak, Sundance, Pebble Beach, Muhammad Ali, Robert Redford, the Golden Gate National Parks Conservancy, and many more. From his studio in Marin County, CA Michael has and is still winning awards in virtually every major graphic design and illustration competition and is regularly featured in publications worldwide.


text:
Rocky Mountain Ridged Mussel
Scientific Name: Gonidea angulata
Taxonomy Group: Molluscs
COSEWIC Status Criteria: B1ab(i,ii,iii,v)+2ab(i,ii,iii,v)
This mussel, one of only a few species of freshwater mussel in British Columbia, is restricted in Canada to the Okanagan basin. Historically, channelization and water regulation in the Okanagan River have affected mussel beds and caused population reduction. Additional sites have been found since the original COSEWIC assessment (2003). Currently, Zebra and Quagga (dreissenid) Mussels are the most serious potential threat to the native mussel. Dreissenid mussels have had devastating effects on native unionid communities elsewhere, such as in the Great Lakes region. A recent assessment of the sensitivity of the Okanagan basin to dreissenid mussels demonstrated that the latter could spread quickly and establish intense infestation on native mussels once introduced. Within the foreseeable future, the introduction of dreissenids into the Okanagan basin is likely because they can survive for days out of water and are known to be transported between water bodies on trailered watercrafts; dreissenid mussels have been intercepted on trailered boats heading to British Columbia in recent years. Ongoing foreshore and riparian development, and some methods of control of invasive Eurasian Watermilfoil reduces habitat and affects water quality.
COSEWIC History of Status Designation: Designated Special Concern in November 2003. Status re-examined and designated Endangered in November 2010.
SARA Status: Schedule 1, Special Concern
Quick Links: | Taxonomy | Description | Distribution and Population | Habitat | Biology | Threats | Protection | Recovery Team | National Recovery Program | Documents
The taxonomic relationship between the Rocky Mountain Ridged Mussel and other subgroups of the same family is uncertain. Until we know more about this mussel, which does not appear to be closely related to any other species in North America, the Rocky Mountain Ridged Mussel must be classified as a very particular genus of the pearly mussel family.
The Rocky Mountain Ridged Mussel is a large freshwater mussel. Its shell is trapezoidal and up to 12.5 cm long and 0.4 cm wide. It is typically rather thin, but can be up to 6.5 cm high toward the posterior. Like that of all other mussels, the shell of the Rocky Mountain Ridged Mussel is composed of two parts, known as valves, connected by a hinge. This hinge is medium-sized and has small, irregular, indistinct anterior teeth. The surface of the shell is marked by well-defined growth rings, and the dorsal valve is distinguished by a sharp, prominent ridge at the beak. In juveniles of this species, the outside of the shell is greenish or ochre, while adults are typically darker, becoming bluish-black. The inside of the shell is white tinged with coppery blue.
The Rocky Mountain Ridged Mussel occurs from southern British Columbia to southern California and eastward to southern Idaho and northern Nevada in the United States. In Canada, this species is limited to the Columbia River system and its tributaries, including the Okanagan and Kootenay rivers. This species is probably also present in other similar areas in southern British Columbia. Currently, there are two distinct, severely fragmented populations of this mussel in British Columbia: one at about eight locations on the Okanagan River, and the other at an undetermined number of locations on the Kootenay River. The size of these populations is not known. The presence of this species has been confirmed recently at only one of the eight locations where it has been observed in the past. This location is Park Rill Creek, a tributary of the Okanagan River, where a dead specimen was collected in 2002 near the town of Oliver. Given the small number of specimens that have been gathered and preserved in collections in Canada, and the decline in water quality, these populations are regarded as being in decline.
The Rocky Mountain Ridged Mussel lives in fresh water. It is found in various sizes of lakes and streams in shallow water where the flow is constant and especially where the bottom is composed of fine material. The species seems to avoid murky, nutrient-rich water. This mussel will attach itself to gravel or firm mud on the bottom so long as this bottom also contains a small amount of fine material such as sand or clay; depending on how fine the bottom is, the mussel may bury itself partially or completely. It is not unusual to see individuals of all non-larval age classes together at a single location.
Little is known about the biology of this species, but it is assumed that, like the other freshwater mussels of North America, it reproduces by the internal fertilization of the female and the production of small larvae called glochidia. After developing in the gills of the female mussel, the larvae are expelled from April to July and drift in the water until they attach themselves to the gills or fins of a host fish. (The species of this host fish is still unknown but, partly because of the large historical range of this mussel, it is believed that a number of different species might actually be involved.) After one to six weeks, the larvae, which have grown into juvenile mussels, drop off the host fish and float freely near the bottom, where they attach themselves once they become adults. The adults generally remain attached to the bottom and cannot move unless disturbed several times. Rocky Mountain Ridged Mussels probably feed on bacteria and algae, which they ingest by filtering the water. As with all freshwater mussels, the survival rate of the larvae is low. According to counts of annual growth rings, it is estimated that the adult can live up to 30 years.
The Rocky Mountain Ridged Mussel is threatened by the destruction and degradation of its habitat. Like all members of this family of mussels, it is highly sensitive to changes in its environment, such as those affecting the temperature or composition of the water. Consequently, several species in this family are endangered in North America. In British Columbia, plans to develop the Okanagan River could have a negative impact on the mussel populations by causing fluctuations in water levels, among other things. In the long term, however, this development could prove beneficial to the species by facilitating its dispersal and creating suitable new habitats. Another threat to the Rocky Mountain Ridged Mussel is the eutrophication of lakes and streams, a process in which increased amounts of nutrients, released largely from agriculture and aquaculture, cause aquatic vegetation to proliferate and reduce the oxygen levels in the water. Also, as filtering organisms, these mussels are generally vulnerable to pollution and particularly to heavy metals, because as the mussels filter large volumes of water in order to feed, the dissolved pollutants from the water build up in their bodies. The proliferation of exotic species such as zebra mussels is also a source of concern.
The Rocky Mountain Ridged Mussel is protected under the federal Species at Risk Act (SARA). More information about SARA, including how it protects individual species, is available in the Species at Risk Act: A Guide.
South Okanagan Invertebrates at Risk Recovery Team
Orville Dyer - Chair/Contact - Government of BC
Jennifer Heron - Chair/Contact - Government of BC
Reports on the Progress of Recovery Document Implementation (1 record(s) found.)
Management Plans (1 record(s) found.)
Reports on the Progress of Recovery Document Implementation
Report on the Progress of Management Plan Implementation for the Rocky Mountain Ridged Mussel (Gonidea angulata) in Canada for the Period 2011- 2016 (2017-08-28)
The Rocky Mountain Ridged Mussel (Gonidea angulata) was listed as a species of Special Concern under the Species at Risk Act (SARA) in 2005. The Management Plan for the Rocky Mountain Ridged Mussel (Gonidea angulata) in British Columbia (DFO 2011) was finalized and published on the Species at Risk Public Registry in 2011.
COSEWIC assessment and status report on the Rocky mountain ridged mussel Gonidea angulata in Canada (2011-09-09)
The freshwater mussel Gonidea angulata, commonly known as the Rocky Mountain Ridged Mussel, was described by Lea in 1839. The shell is up to 125 mm long, 65 mm high, 40 mm wide, and with shell wall up to about 5 mm thick at mid-anterior; variable in form but typically rather thin, trapezoidal in shape, with posterior margin obliquely flattened and relatively broad, and with a sharp and prominent posterior ridge running from the umbo to the angular basal posterior margin of each valve. Juveniles of this species may be greenish/tan in appearance while adults are typically darker, becoming bluish-black.
Response Statement - Rocky Mountain Ridged Mussel (2004-10-22)
The distribution of this species is limited to southern British Columbia in the Okanagan and Kootenay River systems. This species has likely been impacted by the damming of the Kootenay, Columbia and Okanagan Rivers and the channelization of the Okanagan River and resulted in loss or alteration of the mussel's habitat quality and extent.
Management Plan for the Rocky Mountain Ridged Mussel (Gonidea angulata) in British Columbia (2011-07-15)
The Rocky Mountain Ridged Mussel is a freshwater mollusc and was listed as a species of special concern under the Species at Risk Act (SARA), in July 2005. This large freshwater bivalve has a trapezoidal shell. The most distinctive feature of the shell is a prominent posterior ridge running almost parallel with the anterior margin, from the umbo to the angular basal posterior margin of each valve. The posterior length of the shell exceeds the anterior length of the shell.
Order Amending Schedule 1 to the Species at Risk Act (Volume 153, Number 17, 2019) (2019-08-21)
Biodiversity is rapidly declining at all scales, from local to global, as a result of a variety of human activities that increase the rates of species extinction. Current extinction rates are estimated to be between 1 000 and 10 000 times higher than the natural background rate. Higher species diversity positively supports healthy and productive ecosystems that are more resilient to disturbances, and, given the interdependency of species, a loss of biodiversity can lead to a declining resilience of ecosystem functions and services (e.g. natural processes such as pest control, pollination, coastal wave attenuation, pharmaceutical products, temperature regulation and carbon fixing). These services are vital to the health of all Canadians and are important for Canada's economic well-being. Biodiversity loss can therefore result in adverse, irreversible and broad-ranging effects on Canadians.


Last month, while conservatives went into panic mode over those eight Syrians who crossed the US-Mexico border shortly after the Paris attacks, the feds were scrambling to keep up with a more familiar sight in South Texas: the arrival of unaccompanied children and families from Central America.
In October and November, nearly 10,600 kids traveling by themselves were apprehended at the border, more than twice as many as during the same period in 2014—and roughly the same number apprehended at the height of last year's surge, in June 2014. Another 12,500 people traveling as families were caught, a 176 percent jump from October-November 2014. The vast majority came from Central America's so-called Northern Triangle—El Salvador, Guatemala, and Honduras—which continues to be the site of extreme violence, poverty, and, lately, drought.
The spike in apprehensions was surprising for a couple of reasons: First, the numbers of both unaccompanied children and family unit apprehensions have dropped steadily over the past year, and second, the fall and winter months are often quiet ones at the border.
4. The feds are opening more temporary facilities for kids. They're also letting them out quicker. "The Department of Health and Human Services wants to shelter up to 9,800 kids right now. They're at 8,400 since November. They have two camps that they've contracted with in Texas right now for up to 1,000 kids. And they have an agreement with the Department of Defense that they would put them on notice, so every 30 days they can request to have beds online in case they need them. But they haven't had to use any yet.


24 Oct Get the ITIL Foundation Complete Certification Kit - Fourth Edition: Study Guide Book and Online Course at Microsoft Store and compare. Itil Foundation Complete Certification Kit - Fourth Edition has 10 ratings and 3 reviews. Danial said: I can't categorically state that I will be able to. Find great deals for ITIL Foundation Complete Certification Kit - Fourth Edition: Study Guide Book and Online Course by Ivanka Menken (, Paperback).
Buy the eBook ITIL Foundation Complete Certification Kit - Fourth Edition, Study Guide Book and Online Course by Ivanka Menken online from Australia's. Buy the Itil Foundation Complete Certification Kit - Fourth Edition (ebook) online from Takealot. Many ways to pay. Free Delivery Available. Non-Returnable. Read ITIL Foundation Complete Certification Kit - Fourth Edition: Study Guide Book and Online Course by Ivanka Menken with Rakuten Kobo. The ITIL®.


Free places at our Business Breakfast events - saving £200 a year!
Keep up to date with the latest business news through our monthly digital magazine Comment, our regular email updates and our mobile app.
Click here to join online today or call our Membership Team on 01744 742125.


Once I distributed both boot wims, I stopped getting the "PXE-E53: No boot filename received" error. Move network card used in production to the first place. Tuesday, May 31, 2011 7:12 AM Reply | Quote 0 Sign in to vote Hi, this is a configmgr forum, not a wds forum. Selected Computer Management, Operating System Deployment, Boot Images. 3.
Does mean=mode imply a symmetric distribution? i kinda need to report why i think OSD is failing to work. regards Kevin Wednesday, April 08, 2009 2:33 AM Reply | Quote 0 Sign in to vote well, to Very helpful Somewhat helpful Not helpful End of content United StatesHewlett Packard Enterprise International Start of Country Selector content Select Your Country/Region and Language Click or use the tab key to Try moving the PC to a different location, or PXE booting a different machine.
DF. Add back in 5. Add boot images (both of course) to PXE DP That didnt help I have upgraded my WAIK to 1.1 and exported the boot images from that the TS is going off without a hitch Proposed as answer by Lehnoxx Wednesday, July 13, 2011 8:44 AM Wednesday, April 08, 2009 5:34 AM Reply | Quote 0 Sign in Submit a Threat Submit a suspected infected fileto Symantec.
I fixed it by the re-updating the distribution points with my boot image, Boot Image (x86) in my case. About Advertising Privacy Terms Help Sitemap × Join millions of IT pros like you Log in to Spiceworks Reset community password Agree to Terms of Service Connect with Or Sign up exists. That didnt help Has anyone (Wally?) got a definite answer to this pxe issue. I didnt have any problems with my test lab and when I saw all Thank you in advance!
If client and pxe server couldnt' communicate, the result wouldn't be error PXE-E53..right? Any idea? Can that be a link issue? Most routers in a network will forward DHCP request packets to the DHCP server, however they are not set up by default to forward these same packets to a PXE server.
Help Desk » Inventory » Monitor » Community » I wrote a book and am getting offers for to publish. Nothing seems to be working, and I'm starting to go nuts here. If it's not in my collection or brand new, it stops and says there is no task sequence.
I'm having the exact same issue as you, with SP1. After I added the computer to the Administrators group I reinstalled my PXE site server roll on the site server. This problem was fixed six to nine months later when the backplane finally died completely. –Katherine Villyard Oct 18 '14 at 12:40 Er. Under very rare circumstances, the BStrap.0 file can become corrupted in relation to PXE 1.0 client computers and may require a reinstall of the PXE services.
If they plugged a machine into a switch connected to the backplane, it worked. For example, if DHCP and PXE are on separate servers, the DHCP relay agent needs to have both addresses in its configuration. Provide feedback Please rate the information on this page to help us improve our content. I have the PXE setup within SCCM 2007 R2 SP2.
If on the PXE server, create firewall exceptions in your application for both the TFTP and PXE Server services to the exception list (to find the service executable names and locations, Once I added scope option 66 and pointed it to the name of my server and option 67 to boot\x86\wdsnbp.com Everything worked!! You need to configure this. We are allowing unknown computers to PXE boot, and I had not checked "Enable unknown computer support." That's all it was.
For example, if DHCP and PXE are on separate servers, the DHCP relay agent needs to have both addresses in its configuration. If the client computer does not hear back anything from the Altiris PXE server, and does not receive a boot menu, then it will show the error as shown below: Solution Verify that the service account has sufficient rights to run the service (it should be set to "Local System"). Before I got the chance to study it more carefully, one of our help desk techs wiped her machine.
Thank you for your feedback! Nothing seems to be working, and I'm starting to go nuts here. PXE Service is not running: If the PXE Server service is not running, start the service up and make sure that it stays running. Again it skips a few lines and the blinking line continues forever.
Selected Computer Management, Operating System Deployment, Boot Images. 3. If no other machines are working, check your DHCP/PXE server configuration. Submit a False Positive Report a suspected erroneous detection (false positive). Delete the Obsolete machine record. 5.


text:
Simple Youtube Downloader
=========================

![MainScreen](http://i.imgur.com/8lWkRsz.png)

A simple wrapper ui for windows around youtube-dl library.


text:
Shay Given not settling for Villa backup role
by Tribal Football Staff 2015-03-31 09:17:44.000000
Shay Given retains hope of re-establishing himself as Aston Villa's No1.
He still feels capable of mounting serious pressure on current first-choice goalkeeper Brad Guzan.
"I'm delighted to have played for Ireland (against Poland) again," he said.
"I didn't have an awful lot to do but it's up to me to try to get in the Villa team again now.
"I've got a cup semi-final coming up in a couple of weeks and there's the England game in June as well and the Scotland game too so hopefully I can show Martin O'Neill how good I am over the coming weeks."
EPL News
Tribal Football Staff


Instead, make a 'note' on your weekly calendar to update your status, but be as intuitive as you can about it. If you don't have anything you feel compelled to say, share or inquire about, then hold off. The more rigid you become about rules of thumb on social networking activity, the more unnatural it comes across to the audience you are trying to attract.