Coverage Report

Coverage Report - org.perfidix.meter.FileMeter

Classes in this File

Line Coverage

Branch Coverage

Complexity

FileMeter

45%

15/33

30%

6/20

2.875

 package org.perfidix.meter;
 
 import java.io.File;
 import java.math.BigDecimal;
 import java.math.MathContext;
 
 /**
  * File meter for measuring the size of a file or directory registered beforehand.
  * 
  * @author Sebastian Graf, University of Konstanz
  * 
  */
 public class FileMeter extends AbstractMeter {
 
     /** Static name of meter. */
     private static final String NAME = "FileMeter";
 
     /** Reference to file to be benched. */
     private final File mFile;
 
     /** Scale of memory. */
     private transient final Memory mScale;
 
     /**
      * Constructor.
      * 
      * @param pFile
      *            to be evaluated, is going to be traversed recursively
      * @param pScale
      *            for returning the data
      */
     public FileMeter(final File pFile, final Memory pScale) {
         super();
         mFile = pFile;
         mScale = pScale;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public double getValue() {
         long size = iterateRecursive(mFile);
         return new BigDecimal(size, MathContext.DECIMAL128).divide(new BigDecimal(mScale.getNumberOfBytes()),
             MathContext.DECIMAL128).doubleValue();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getUnit() {
         return mScale.getUnit();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getUnitDescription() {
         return mScale.getUnitDescription();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getName() {
         return NAME;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + ((mFile == null) ? 0 : mFile.hashCode());
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         FileMeter other = (FileMeter)obj;
         if (mFile == null) {
             if (other.mFile != null)
                 return false;
         } else if (!mFile.equals(other.mFile))
             return false;
         return true;
     }
 
     private static long iterateRecursive(final File pFile) {
         long size = 0;
         if (pFile.isDirectory()) {
             for (final File child : pFile.listFiles()) {
                 size = size + iterateRecursive(child);
             }
         }
         if (pFile.isFile()) {
             size = size + pFile.length();
         }
         return size;
     }
 
 }

1		package org.perfidix.meter;
2
3		import java.io.File;
4		import java.math.BigDecimal;
5		import java.math.MathContext;
6
7		/**
8		* File meter for measuring the size of a file or directory registered beforehand.
9		*
10		* @author Sebastian Graf, University of Konstanz
11		*
12		*/
13		public class FileMeter extends AbstractMeter {
14
15		/** Static name of meter. */
16		private static final String NAME = "FileMeter";
17
18		/** Reference to file to be benched. */
19		private final File mFile;
20
21		/** Scale of memory. */
22		private transient final Memory mScale;
23
24		/**
25		* Constructor.
26		*
27		* @param pFile
28		* to be evaluated, is going to be traversed recursively
29		* @param pScale
30		* for returning the data
31		*/
32		public FileMeter(final File pFile, final Memory pScale) {
33	45	super();
34	45	mFile = pFile;
35	45	mScale = pScale;
36	45	}
37
38		/**
39		* {@inheritDoc}
40		*/
41		@Override
42		public double getValue() {
43	15	long size = iterateRecursive(mFile);
44	15	return new BigDecimal(size, MathContext.DECIMAL128).divide(new BigDecimal(mScale.getNumberOfBytes()),
45		MathContext.DECIMAL128).doubleValue();
46		}
47
48		/**
49		* {@inheritDoc}
50		*/
51		@Override
52		public String getUnit() {
53	15	return mScale.getUnit();
54		}
55
56		/**
57		* {@inheritDoc}
58		*/
59		@Override
60		public String getUnitDescription() {
61	15	return mScale.getUnitDescription();
62		}
63
64		/**
65		* {@inheritDoc}
66		*/
67		@Override
68		public String getName() {
69	0	return NAME;
70		}
71
72		/**
73		* {@inheritDoc}
74		*/
75		@Override
76		public int hashCode() {
77	0	final int prime = 31;
78	0	int result = 1;
79	0	result = prime * result + ((mFile == null) ? 0 : mFile.hashCode());
80	0	return result;
81		}
82
83		/**
84		* {@inheritDoc}
85		*/
86		@Override
87		public boolean equals(Object obj) {
88	0	if (this == obj)
89	0	return true;
90	0	if (obj == null)
91	0	return false;
92	0	if (getClass() != obj.getClass())
93	0	return false;
94	0	FileMeter other = (FileMeter)obj;
95	0	if (mFile == null) {
96	0	if (other.mFile != null)
97	0	return false;
98	0	} else if (!mFile.equals(other.mFile))
99	0	return false;
100	0	return true;
101		}
102
103		private static long iterateRecursive(final File pFile) {
104	156	long size = 0;
105	156	if (pFile.isDirectory()) {
106	183	for (final File child : pFile.listFiles()) {
107	141	size = size + iterateRecursive(child);
108		}
109		}
110	156	if (pFile.isFile()) {
111	114	size = size + pFile.length();
112		}
113	156	return size;
114		}
115
116		}