Free military units software for linux

Qalculate! is a multi-purpose desktop calculator for GNU/Linux. Qalculate! project is small and simple to use but with much power and versatility underneath.
Features include customizable functions, units, arbitrary precision, plotting, and a user-friendly interface (KDE or GTK+).
Main features:
- Redesigned GUI with history view in the main window
- Display of as-you-type expression parsing and function hints
- Enhanced completion
- Scaling of result display to vertically fit the window
- Nicer history listing
- Enhanced result display with much nicer parentheses
- Meta modes
- 67 new units: bel (B) and neper (Np), information units such as bit and byte, many convenience units (km/h, deciliter, etc), and more.
- Binary prefixes
- Some new variables and functions
- Fixed help display in new yelp
- Fixed compile with cln-1.1.10
- Fixed regressions in simplification
- Fixed f(x) return type analysis (ex. log(x) represents a real number if x represents a positive). This was by accident unused.
- ...and many more bug fixes and enhancements...

DailyTasks project is a program for reminding you of daily tasks.
I, basically, created DailyTasks to fulfill a need of my own. I am much too disorganized to use "standard" task managemenet programs: every time I tried, I seemed to spend more time setting up and updating tasks than I actually spent doing the tasks themselves... On the other hand, a simple way of reminding me of them would be useful.
Also, most tasks seem to be of the repeating kind. That is, its something you have to do every day. What I needed, then, was a way to remind me -- or simply to show me -- that, today, I still had this, that and that to do.
I looked around for some already existing software to do exactly this... and found only one: frequent-task-reminder. Its based on the concept of "work units"; that is, after you set up a task, it increases by one remaining work unit each day. It was mostly what I wanted, but, after trying it out, I quickly found that there were a couple of features I wanted it to have, and it didnt. The main one was this: there should be an option to stop increasing the work units above 1. Some tasks simply dont accumulate. Oh, and I wanted a web interface, too.
The web interface, I even ended up writing myself. :) But frequent-task-reminder is written in Python, a language I have about zero experience with. While this would be a good excuse to learn it, :), I decided, instead, to start from scratch, and write DailyTasks, in PHP.
Main features:
- Web interface included as an alternative to command line mode
- Tasks file is a simple, easy to edit text file, instead of XML
- 3 task modes: normal (increases one work unit per day), max 1 (doesnt increase beyond 1 remaining work unit), and standby (doesnt increase at all)
- Ability to manually set the remaining work units for a task
- Doesnt keep track of dates; requires a special invocation (usually by cron) to increase work units
- Written in PHP instead of Python.
Installation
Command line
First, you need PHP. I only tested DailyTasks on PHP 5.x, but the 4.x versions should work as well.
If you compiled PHP by hand, you probably have everything you need already. If youre using a precompiled package, note that many distributions separate PHP in two packages: the "web" version and the "command line" version. You need the latter (and any dependencies it may have). On Ubuntu, for instance, its called php5-cli.
After you have PHP, simply put the dailytasks file somewhere in your path. Edit it and, if needed, change the first line to point to where you have php installed (it may be in /usr/bin/php, /usr/local/bin/php, or, in rare cases, something else).
Web interface
Requirements: a web server (probably Apache) with PHP support.
You need to install the command line version first, of course (see above). Warning: if youre using a chrooted Apache, you need to put dailytasks somewhere inside the chroot.
Finally, just put all the DailyTasks *.php and *.css files on an accessible web directory. Add some kind of authentication, possibly using a .htaccess file, if needed.
Usage
Command line
Simply run dailytasks without any parameters, and youll get this help:
Available options:
-x : increase each tasks work units by one. Typically used by cron.
-a task : add a new task called task. Use quotes if the name has more
than one word.
-l : list all tasks
-c : list all tasks with 1 or more pending work units.
-w tasknumber : work -- reduce tasks pending units by 1.
-r tasknumber : set remaining work units for that task to zero.
-m tasknumber mode: set the tasks type to the listed mode.
available modes are:
0: stand-by -- work units dont increase automatically.
1: max 1 -- work units increase up to 1 (i.e. no accumulation).
2: normal -- work units increase by 1 each day, with no limit.
-s tasknumber units: set remaining work units to the supplied value.
-d tasknumber: delete the task completely. Task numbers change after this operation.
You should probably add:
0 0 * * * path/to/dailytasks -x
to your crontab.
Web interface
The web interface is (hopefully) self-explanatory, as long as you are aware of the command line options (see above). I may attempt to make any future versions more user friendly.

Test::Unit is the main PerlUnit testing framework.

SYNOPSIS

This package provides only the project version number, copyright texts, and a framework overview in POD format.

This framework is intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.) and is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma. To start learning how to use this framework, see Test::Unit::TestCase and Test::Unit::TestSuite. (There will also eventually be a tutorial in Test::Unit::Tutorial.

However Test::Unit::Procedural is the procedural style interface to a sophisticated unit testing framework for Perl that . Test::Unit is intended to provide a simpler interface to the framework that is more suitable for use in a scripting style environment. Therefore, Test::Unit does not provide much support for an object-oriented approach to unit testing.

p-unit is a framework for benchmarking performance. The project records memory consumption and execution time, and generates results in the form of plain text, image, and PDF file. Users can also easily register their own reporters by implementing PUnitEventList.
Test Suite and Test Class
Test suite and test class are two important concepts in p-unit. p-unit does not require any special type for a test class, so every class can be a test class. Of course, it includes junit test cases. There is one special interface for special p-unit only test class - p-unitTest. p-unit executes a normal test as following procedure:
invoke setUp if there is.
invoke the test method.
invoke tearDown method.
Noticed that setUp and tearDown will also be regarded as a part of performance test. If you dont want to count them into performance data, you need to implement p-unitTest interface, which will be executed as:
invoke setUpBeforeWatchers.
invoke setAfterWatchers.
invoke the test method.
invoke tearDownBeforeWatchers.
invoke tearDownAfterWatchers.
As the name suggests, you can put the setUp and tearDown code into the setUpBeforeWatchers and tearDownAfterWatchers.
Time/Memory Record
p-unit records the memory and time consumption of running a test method. There is a "watcher" concept in p-unit, which supervises the status during running the test method. By default, memory watcher and time watcher are installed. p-unit supports user-defined watcher too. The user only needs to implement the Watcher interface and register it to p-unit method runner.
Enhancements:
- Changes to adopt the Apache License 2.0.
- A customized watcher infrastructure to make it possible to report results from test cases.
- A new EventListener that sets public test fields on start up.

Test::Unit::TestCase is a unit testing framework base class.

SYNOPSIS

package FooBar;
use base qw(Test::Unit::TestCase);

sub new {
my $self = shift()->SUPER::new(@_);
# your state for fixture here
return $self;
}

sub set_up {
# provide fixture
}
sub tear_down {
# clean up after test
}
sub test_foo {
# test the foo feature
}
sub test_bar {
# test the bar feature
}

(Taken from the JUnit TestCase class documentation)

A test case defines the "fixture" (resources need for testing) to run multiple tests. To define a test case:

implement a subclass of TestCase
define instance variables that store the state of the fixture
initialize the fixture state by overriding set_up()
clean-up after a test by overriding tear_down().

Each test runs in its own fixture so there can be no side effects among test runs. Here is an example:

package MathTest;
use base qw(Test::Unit::TestCase);

sub new {
my $self = shift()->SUPER::new(@_);
$self->{value_1} = 0;
$self->{value_2} = 0;
return $self;
}

sub set_up {
my $self = shift;
$self->{value_1} = 2;
$self->{value_2} = 3;
}

For each test implement a method which interacts with the fixture. Verify the expected results with assertions specified by calling $self->assert() with a boolean value.

sub test_add {
my $self = shift;
my $result = $self->{value_1} + $self->{value_2};
$self->assert($result == 5);
}

Once the methods are defined you can run them. The normal way to do this uses reflection to implement run_test. It dynamically finds and invokes a method. For this the name of the test case has to correspond to the test method to be run. The tests to be run can be collected into a TestSuite. The framework provides different test runners, which can run a test suite and collect the results. A test runner either expects a method suite() as the entry point to get a test to run or it will extract the suite automatically.

If you do not like the rather verbose backtrace that appears when a test fails, you can use the quell_backtrace() method. You will get any message provided, but not the backtrace.

Veterans Health Information Systems and Technology Architecture is a healthcare information system (HIS). VistA is widely believed to be the largest integrated HIS in the world. WorldVistA project was originally developed and maintained by the U.S.
Department of Veterans Affairs (VA), based on the systems software architecture and implementation methodology developed by the U.S. Public Health Service jointly with the National Bureau of Standards.
It is designed to provide a high-quality medical care environment for the countrys military veterans. VistA has a proven track record of supporting a large variety of clinical settings and medical delivery systems.
Enhancements:
- This is the FOIAVistA SemiVivA 20060113 package with GT.M bundled.

Fantasy Battlefields software is a free turn-based tactical battle game located in a fantasy universe. Each player leads an army to fight against the armies of virtual enemies (artificial intelligence) or against other players on a network or on the same computer.

Each army is composed of a great number of fighters having their specific characteristics (Strength, Movement ...) and is organized according to a determined hierarchy (commands, units, individuals ...) Developped in Java, this game is a multi-platform game (Linux, Mac, Windows or others).

Test::Unit::TestRunner is a unit testing framework helper class.

SYNOPSIS

use Test::Unit::TestRunner;

my $testrunner = Test::Unit::TestRunner->new();
$testrunner->start($my_testcase_class);

This class is the test runner for the command line style use of the testing framework.

It is used by simple command line tools like the TestRunner.pl script provided.
The class needs one argument, which is the name of the class encapsulating the tests to be run.

OPTIONS

-wait
wait for user confirmation between tests

-v
version info